home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / PInterfaces / Files.p < prev    next >
Encoding:
Text File  |  1996-05-01  |  75.9 KB  |  2,176 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Files.p
  3.  
  4.      Contains:    File Manager (HFS and MFS) Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT Files;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __FILES__}
  28. {$SETC __FILES__ := 1}
  29.  
  30. {$I+}
  31. {$SETC FilesIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __MIXEDMODE__}
  38. {$I MixedMode.p}
  39. {$ENDC}
  40. {$IFC UNDEFINED __OSUTILS__}
  41. {$I OSUtils.p}
  42. {$ENDC}
  43. {$IFC NOT OLDROUTINELOCATIONS }
  44. {$IFC UNDEFINED __FINDER__}
  45. {$I Finder.p}
  46. {$ENDC}
  47. {$ENDC}
  48.  
  49. {$PUSH}
  50. {$ALIGN MAC68K}
  51. {$LibExport+}
  52.  
  53. {$IFC FOR_SYSTEM7_AND_SYSTEM8_DEPRECATED }
  54.  
  55. CONST
  56.     fsAtMark                    = 0;
  57.     fsCurPerm                    = 0;
  58.     fsRdPerm                    = 1;
  59.     fInvisible                    = 16384;
  60.     fsWrPerm                    = 2;
  61.     fsRdWrPerm                    = 3;
  62.     fsRdWrShPerm                = 4;
  63.     fsFromStart                    = 1;
  64.     fsFromLEOF                    = 2;
  65.     fsFromMark                    = 3;
  66.     rdVerify                    = 64;
  67.     ioMapBuffer                    = 4;
  68.     ioModeReserved                = 8;
  69.     ioDirFlg                    = 4;                            {  see IM IV-125  }
  70.     ioDirMask                    = $10;
  71.     fsRtParID                    = 1;
  72.     fsRtDirID                    = 2;
  73.  
  74. {$IFC OLDROUTINELOCATIONS }
  75. {  Finder Constants  }
  76.     fOnDesk                        = 1;
  77.     fHasBundle                    = 8192;
  78.     fTrash                        = -3;
  79.     fDesktop                    = -2;
  80.     fDisk                        = 0;
  81.  
  82. {$ENDC}
  83.                                                                 {  CatSearch SearchBits Constants  }
  84.     fsSBPartialName                = 1;
  85.     fsSBFullName                = 2;
  86.     fsSBFlAttrib                = 4;
  87.     fsSBFlFndrInfo                = 8;
  88.     fsSBFlLgLen                    = 32;
  89.     fsSBFlPyLen                    = 64;
  90.     fsSBFlRLgLen                = 128;
  91.     fsSBFlRPyLen                = 256;
  92.     fsSBFlCrDat                    = 512;
  93.     fsSBFlMdDat                    = 1024;
  94.     fsSBFlBkDat                    = 2048;
  95.     fsSBFlXFndrInfo                = 4096;
  96.     fsSBFlParID                    = 8192;
  97.     fsSBNegate                    = 16384;
  98.     fsSBDrUsrWds                = 8;
  99.     fsSBDrNmFls                    = 16;
  100.     fsSBDrCrDat                    = 512;
  101.     fsSBDrMdDat                    = 1024;
  102.     fsSBDrBkDat                    = 2048;
  103.     fsSBDrFndrInfo                = 4096;                            {  bit values for the above  }
  104.     fsSBPartialNameBit            = 0;                            { ioFileName points to a substring }
  105.     fsSBFullNameBit                = 1;                            { ioFileName points to a match string }
  106.     fsSBFlAttribBit                = 2;                            { search includes file attributes }
  107.     fsSBFlFndrInfoBit            = 3;                            { search includes finder info }
  108.     fsSBFlLgLenBit                = 5;                            { search includes data logical length }
  109.     fsSBFlPyLenBit                = 6;                            { search includes data physical length }
  110.     fsSBFlRLgLenBit                = 7;                            { search includes resource logical length }
  111.     fsSBFlRPyLenBit                = 8;                            { search includes resource physical length }
  112.     fsSBFlCrDatBit                = 9;                            { search includes create date }
  113.     fsSBFlMdDatBit                = 10;                            { search includes modification date }
  114.     fsSBFlBkDatBit                = 11;                            { search includes backup date }
  115.     fsSBFlXFndrInfoBit            = 12;                            { search includes extended finder info }
  116.     fsSBFlParIDBit                = 13;                            { search includes file's parent ID }
  117.     fsSBNegateBit                = 14;                            { return all non-matches }
  118.     fsSBDrUsrWdsBit                = 3;                            { search includes directory finder info }
  119.     fsSBDrNmFlsBit                = 4;                            { search includes directory valence }
  120.     fsSBDrCrDatBit                = 9;                            { directory-named version of fsSBFlCrDatBit }
  121.     fsSBDrMdDatBit                = 10;                            { directory-named version of fsSBFlMdDatBit }
  122.     fsSBDrBkDatBit                = 11;                            { directory-named version of fsSBFlBkDatBit }
  123.     fsSBDrFndrInfoBit            = 12;                            { directory-named version of fsSBFlXFndrInfoBit }
  124.  
  125.     fsSBDrParID                    = 8192;
  126.     fsSBDrParIDBit                = 13;                            { directory-named version of fsSBFlParIDBit }
  127.                                                                 {  vMAttrib (GetVolParms) bit position constants  }
  128.     bLimitFCBs                    = 31;
  129.     bLocalWList                    = 30;
  130.     bNoMiniFndr                    = 29;
  131.     bNoVNEdit                    = 28;
  132.     bNoLclSync                    = 27;
  133.     bTrshOffLine                = 26;
  134.     bNoSwitchTo                    = 25;
  135.     bNoDeskItems                = 20;
  136.     bNoBootBlks                    = 19;
  137.     bAccessCntl                    = 18;
  138.     bNoSysDir                    = 17;
  139.     bHasExtFSVol                = 16;
  140.     bHasOpenDeny                = 15;
  141.     bHasCopyFile                = 14;
  142.     bHasMoveRename                = 13;
  143.     bHasDesktopMgr                = 12;
  144.     bHasShortName                = 11;
  145.     bHasFolderLock                = 10;
  146.     bHasPersonalAccessPrivileges = 9;
  147.  
  148.     bHasUserGroupList            = 8;
  149.     bHasCatSearch                = 7;
  150.     bHasFileIDs                    = 6;
  151.     bHasBTreeMgr                = 5;
  152.     bHasBlankAccessPrivileges    = 4;                            {  Desktop Database icon Constants  }
  153.     kLargeIcon                    = 1;
  154.     kLarge4BitIcon                = 2;
  155.     kLarge8BitIcon                = 3;
  156.     kSmallIcon                    = 4;
  157.     kSmall4BitIcon                = 5;
  158.     kSmall8BitIcon                = 6;
  159.     kLargeIconSize                = 256;
  160.     kLarge4BitIconSize            = 512;
  161.     kLarge8BitIconSize            = 1024;
  162.     kSmallIconSize                = 64;
  163.     kSmall4BitIconSize            = 128;
  164.     kSmall8BitIconSize            = 256;                            {  Foreign Privilege Model Identifiers  }
  165.     fsUnixPriv                    = 1;                            {  Authentication Constants  }
  166.     kNoUserAuthentication        = 1;
  167.     kPassword                    = 2;
  168.     kEncryptPassword            = 3;
  169.     kTwoWayEncryptPassword        = 6;
  170.  
  171. {  mapping codes (ioObjType) for MapName & MapID  }
  172.     kOwnerID2Name                = 1;
  173.     kGroupID2Name                = 2;
  174.     kOwnerName2ID                = 3;
  175.     kGroupName2ID                = 4;                            {  types of oj object to be returned (ioObjType) for _GetUGEntry  }
  176.     kReturnNextUser                = 1;
  177.     kReturnNextGroup            = 2;
  178.     kReturnNextUG                = 3;
  179.  
  180. {$IFC OLDROUTINELOCATIONS }
  181. {
  182.     The following structures are being moved to Finder.i because
  183.     they are Finder centric.  See Finder constants above.
  184. }
  185.  
  186. TYPE
  187.     FInfoPtr = ^FInfo;
  188.     FInfo = RECORD
  189.         fdType:                    OSType;                                    { the type of the file }
  190.         fdCreator:                OSType;                                    { file's creator }
  191.         fdFlags:                INTEGER;                                { flags ex. hasbundle,invisible,locked, etc. }
  192.         fdLocation:                Point;                                    { file's location in folder }
  193.         fdFldr:                    INTEGER;                                { folder containing file }
  194.     END;
  195.  
  196.     FXInfoPtr = ^FXInfo;
  197.     FXInfo = RECORD
  198.         fdIconID:                INTEGER;                                { Icon ID }
  199.         fdUnused:                ARRAY [1..3] OF INTEGER;                { unused but reserved 6 bytes }
  200.         fdScript:                SInt8;                                    { Script flag and number }
  201.         fdXFlags:                SInt8;                                    { More flag bits }
  202.         fdComment:                INTEGER;                                { Comment ID }
  203.         fdPutAway:                LONGINT;                                { Home Dir ID }
  204.     END;
  205.  
  206.     DInfoPtr = ^DInfo;
  207.     DInfo = RECORD
  208.         frRect:                    Rect;                                    { folder rect }
  209.         frFlags:                INTEGER;                                { Flags }
  210.         frLocation:                Point;                                    { folder location }
  211.         frView:                    INTEGER;                                { folder view }
  212.     END;
  213.  
  214.     DXInfoPtr = ^DXInfo;
  215.     DXInfo = RECORD
  216.         frScroll:                Point;                                    { scroll position }
  217.         frOpenChain:            LONGINT;                                { DirID chain of open folders }
  218.         frScript:                SInt8;                                    { Script flag and number }
  219.         frXFlags:                SInt8;                                    { More flag bits }
  220.         frComment:                INTEGER;                                { comment }
  221.         frPutAway:                LONGINT;                                { DirID }
  222.     END;
  223.  
  224. {$ENDC}
  225.  
  226. TYPE
  227.     GetVolParmsInfoBufferPtr = ^GetVolParmsInfoBuffer;
  228.     GetVolParmsInfoBuffer = RECORD
  229.         vMVersion:                INTEGER;                                { version number }
  230.         vMAttrib:                LONGINT;                                { bit vector of attributes (see vMAttrib constants) }
  231.         vMLocalHand:            Handle;                                    { handle to private data }
  232.         vMServerAdr:            LONGINT;                                { AppleTalk server address or zero }
  233.         vMVolumeGrade:            LONGINT;                                { approx. speed rating or zero if unrated }
  234.         vMForeignPrivID:        INTEGER;                                { foreign privilege model supported or zero if none }
  235.     END;
  236.  
  237.     ParmBlkPtr                            = ^ParamBlockRec;
  238.     IOCompletionProcPtr = Register68kProcPtr;  { PROCEDURE IOCompletion(paramBlock: ParmBlkPtr); }
  239.  
  240.     IOCompletionUPP = UniversalProcPtr;
  241.     IOParamPtr = ^IOParam;
  242.     IOParam = RECORD
  243.         qLink:                    QElemPtr;                                { queue link in header }
  244.         qType:                    INTEGER;                                { type byte for safety check }
  245.         ioTrap:                    INTEGER;                                { FS: the Trap }
  246.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  247.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  248.         ioResult:                OSErr;                                    { result code }
  249.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  250.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  251.         ioRefNum:                INTEGER;                                { refNum for I/O operation }
  252.         ioVersNum:                SInt8;                                    { version number }
  253.         ioPermssn:                SInt8;                                    { Open: permissions (byte) }
  254.         ioMisc:                    Ptr;                                    { Rename: new name (GetEOF,SetEOF: logical end of file) (Open: optional ptr to buffer) (SetFileType: new type) }
  255.         ioBuffer:                Ptr;                                    { data buffer Ptr }
  256.         ioReqCount:                LONGINT;                                { requested byte count; also = ioNewDirID }
  257.         ioActCount:                LONGINT;                                { actual byte count completed }
  258.         ioPosMode:                INTEGER;                                { initial file positioning }
  259.         ioPosOffset:            LONGINT;                                { file position offset }
  260.     END;
  261.  
  262.     FileParamPtr = ^FileParam;
  263.     FileParam = RECORD
  264.         qLink:                    QElemPtr;                                { queue link in header }
  265.         qType:                    INTEGER;                                { type byte for safety check }
  266.         ioTrap:                    INTEGER;                                { FS: the Trap }
  267.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  268.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  269.         ioResult:                OSErr;                                    { result code }
  270.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  271.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  272.         ioFRefNum:                INTEGER;                                { reference number }
  273.         ioFVersNum:                SInt8;                                    { version number }
  274.         filler1:                SInt8;
  275.         ioFDirIndex:            INTEGER;                                { GetFInfo directory index }
  276.         ioFlAttrib:                SInt8;                                    { GetFInfo: in-use bit=7, lock bit=0 }
  277.         ioFlVersNum:            SInt8;                                    { file version number }
  278.         ioFlFndrInfo:            FInfo;                                    { user info }
  279.         ioFlNum:                LONGINT;                                { GetFInfo: file number; TF- ioDirID }
  280.         ioFlStBlk:                INTEGER;                                { start file block (0 if none) }
  281.         ioFlLgLen:                LONGINT;                                { logical length (EOF) }
  282.         ioFlPyLen:                LONGINT;                                { physical length }
  283.         ioFlRStBlk:                INTEGER;                                { start block rsrc fork }
  284.         ioFlRLgLen:                LONGINT;                                { file logical length rsrc fork }
  285.         ioFlRPyLen:                LONGINT;                                { file physical length rsrc fork }
  286.         ioFlCrDat:                LONGINT;                                { file creation date& time (32 bits in secs) }
  287.         ioFlMdDat:                LONGINT;                                { last modified date and time }
  288.     END;
  289.  
  290.     VolumeParamPtr = ^VolumeParam;
  291.     VolumeParam = RECORD
  292.         qLink:                    QElemPtr;                                { queue link in header }
  293.         qType:                    INTEGER;                                { type byte for safety check }
  294.         ioTrap:                    INTEGER;                                { FS: the Trap }
  295.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  296.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  297.         ioResult:                OSErr;                                    { result code }
  298.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  299.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  300.         filler2:                LONGINT;
  301.         ioVolIndex:                INTEGER;                                { volume index number }
  302.         ioVCrDate:                LONGINT;                                { creation date and time }
  303.         ioVLsBkUp:                LONGINT;                                { last backup date and time }
  304.         ioVAtrb:                INTEGER;                                { volume attrib }
  305.         ioVNmFls:                INTEGER;                                { number of files in directory }
  306.         ioVDirSt:                INTEGER;                                { start block of file directory }
  307.         ioVBlLn:                INTEGER;                                { GetVolInfo: length of dir in blocks }
  308.         ioVNmAlBlks:            INTEGER;                                { for compatibilty ioVNmAlBlks * ioVAlBlkSiz <= 2 GB }
  309.         ioVAlBlkSiz:            LONGINT;                                { for compatibilty ioVAlBlkSiz is <= $0000FE00 (65,024) }
  310.         ioVClpSiz:                LONGINT;                                { GetVolInfo: bytes to allocate at a time }
  311.         ioAlBlSt:                INTEGER;                                { starting disk(512-byte) block in block map }
  312.         ioVNxtFNum:                LONGINT;                                { GetVolInfo: next free file number }
  313.         ioVFrBlk:                INTEGER;                                { GetVolInfo: # free alloc blks for this vol }
  314.     END;
  315.  
  316.     CntrlParamPtr = ^CntrlParam;
  317.     CntrlParam = RECORD
  318.         qLink:                    QElemPtr;                                { queue link in header }
  319.         qType:                    INTEGER;                                { type byte for safety check }
  320.         ioTrap:                    INTEGER;                                { FS: the Trap }
  321.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  322.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  323.         ioResult:                OSErr;                                    { result code }
  324.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  325.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  326.         ioCRefNum:                INTEGER;                                { refNum for I/O operation }
  327.         csCode:                    INTEGER;                                { word for control status code }
  328.         csParam:                ARRAY [0..10] OF INTEGER;                { operation-defined parameters }
  329.     END;
  330.  
  331.     SlotDevParamPtr = ^SlotDevParam;
  332.     SlotDevParam = RECORD
  333.         qLink:                    QElemPtr;                                { queue link in header }
  334.         qType:                    INTEGER;                                { type byte for safety check }
  335.         ioTrap:                    INTEGER;                                { FS: the Trap }
  336.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  337.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  338.         ioResult:                OSErr;                                    { result code }
  339.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  340.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  341.         ioSRefNum:                INTEGER;
  342.         ioSVersNum:                SInt8;
  343.         ioSPermssn:                SInt8;
  344.         ioSMix:                    Ptr;
  345.         ioSFlags:                INTEGER;
  346.         ioSlot:                    SInt8;
  347.         ioID:                    SInt8;
  348.     END;
  349.  
  350.     MultiDevParamPtr = ^MultiDevParam;
  351.     MultiDevParam = RECORD
  352.         qLink:                    QElemPtr;                                { queue link in header }
  353.         qType:                    INTEGER;                                { type byte for safety check }
  354.         ioTrap:                    INTEGER;                                { FS: the Trap }
  355.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  356.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  357.         ioResult:                OSErr;                                    { result code }
  358.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  359.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  360.         ioMRefNum:                INTEGER;
  361.         ioMVersNum:                SInt8;
  362.         ioMPermssn:                SInt8;
  363.         ioMMix:                    Ptr;
  364.         ioMFlags:                INTEGER;
  365.         ioSEBlkPtr:                Ptr;
  366.     END;
  367.  
  368.     ParamBlockRecPtr = ^ParamBlockRec;
  369.     ParamBlockRec = RECORD
  370.         qLink:                    QElemPtr;                                { queue link in header }
  371.         qType:                    INTEGER;                                { type byte for safety check }
  372.         ioTrap:                    INTEGER;                                { FS: the Trap }
  373.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  374.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  375.         ioResult:                OSErr;                                    { result code }
  376.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  377.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  378.         CASE INTEGER OF
  379.         0: (
  380.             ioRefNum:            INTEGER;                                { refNum for I/O operation }
  381.             ioVersNum:            SInt8;                                    { version number }
  382.             ioPermssn:            SInt8;                                    { Open: permissions (byte) }
  383.             ioMisc:                Ptr;                                    { Rename: new name (GetEOF,SetEOF: logical end of file) (Open: optional ptr to buffer) (SetFileType: new type) }
  384.             ioBuffer:            Ptr;                                    { data buffer Ptr }
  385.             ioReqCount:            LONGINT;                                { requested byte count; also = ioNewDirID }
  386.             ioActCount:            LONGINT;                                { actual byte count completed }
  387.             ioPosMode:            INTEGER;                                { initial file positioning }
  388.             ioPosOffset:        LONGINT;                                { file position offset }
  389.            );
  390.         1: (
  391.             ioFRefNum:            INTEGER;                                { reference number }
  392.             ioFVersNum:            SInt8;                                    { version number }
  393.             filler1:            SInt8;
  394.             ioFDirIndex:        INTEGER;                                { GetFInfo directory index }
  395.             ioFlAttrib:            SInt8;                                    { GetFInfo: in-use bit=7, lock bit=0 }
  396.             ioFlVersNum:        SInt8;                                    { file version number }
  397.             ioFlFndrInfo:        FInfo;                                    { user info }
  398.             ioFlNum:            LONGINT;                                { GetFInfo: file number; TF- ioDirID }
  399.             ioFlStBlk:            INTEGER;                                { start file block (0 if none) }
  400.             ioFlLgLen:            LONGINT;                                { logical length (EOF) }
  401.             ioFlPyLen:            LONGINT;                                { physical length }
  402.             ioFlRStBlk:            INTEGER;                                { start block rsrc fork }
  403.             ioFlRLgLen:            LONGINT;                                { file logical length rsrc fork }
  404.             ioFlRPyLen:            LONGINT;                                { file physical length rsrc fork }
  405.             ioFlCrDat:            LONGINT;                                { file creation date& time (32 bits in secs) }
  406.             ioFlMdDat:            LONGINT;                                { last modified date and time }
  407.            );
  408.         2: (
  409.             filler2:            LONGINT;
  410.             ioVolIndex:            INTEGER;                                { volume index number }
  411.             ioVCrDate:            LONGINT;                                { creation date and time }
  412.             ioVLsBkUp:            LONGINT;                                { last backup date and time }
  413.             ioVAtrb:            INTEGER;                                { volume attrib }
  414.             ioVNmFls:            INTEGER;                                { number of files in directory }
  415.             ioVDirSt:            INTEGER;                                { start block of file directory }
  416.             ioVBlLn:            INTEGER;                                { GetVolInfo: length of dir in blocks }
  417.             ioVNmAlBlks:        INTEGER;                                { for compatibilty ioVNmAlBlks * ioVAlBlkSiz <= 2 GB }
  418.             ioVAlBlkSiz:        LONGINT;                                { for compatibilty ioVAlBlkSiz is <= $0000FE00 (65,024) }
  419.             ioVClpSiz:            LONGINT;                                { GetVolInfo: bytes to allocate at a time }
  420.             ioAlBlSt:            INTEGER;                                { starting disk(512-byte) block in block map }
  421.             ioVNxtFNum:            LONGINT;                                { GetVolInfo: next free file number }
  422.             ioVFrBlk:            INTEGER;                                { GetVolInfo: # free alloc blks for this vol }
  423.            );
  424.         3: (
  425.             ioCRefNum:            INTEGER;                                { refNum for I/O operation }
  426.             csCode:                INTEGER;                                { word for control status code }
  427.             csParam:            ARRAY [0..10] OF INTEGER;                { operation-defined parameters }
  428.            );
  429.         4: (
  430.             ioSRefNum:            INTEGER;
  431.             ioSVersNum:            SInt8;
  432.             ioSPermssn:            SInt8;
  433.             ioSMix:                Ptr;
  434.             ioSFlags:            INTEGER;
  435.             ioSlot:                SInt8;
  436.             ioID:                SInt8;
  437.            );
  438.         5: (
  439.             ioMRefNum:            INTEGER;
  440.             ioMVersNum:            SInt8;
  441.             ioMPermssn:            SInt8;
  442.             ioMMix:                Ptr;
  443.             ioMFlags:            INTEGER;
  444.             ioSEBlkPtr:            Ptr;
  445.            );
  446.     END;
  447.  
  448.     CInfoPBRecPtr = ^CInfoPBRec;
  449.     CInfoPBRec = RECORD
  450.         qLink:                    QElemPtr;                                { queue link in header }
  451.         qType:                    INTEGER;                                { type byte for safety check }
  452.         ioTrap:                    INTEGER;                                { FS: the Trap }
  453.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  454.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  455.         ioResult:                OSErr;                                    { result code }
  456.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  457.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  458.         ioFRefNum:                INTEGER;
  459.         ioFVersNum:                SInt8;
  460.         filler1:                SInt8;
  461.         ioFDirIndex:            INTEGER;
  462.         ioFlAttrib:                SInt8;
  463.         ioACUser:                SInt8;
  464.         CASE INTEGER OF
  465.         0: (
  466.             ioFlFndrInfo:        FInfo;
  467.             ioDirID:            LONGINT;
  468.             ioFlStBlk:            INTEGER;
  469.             ioFlLgLen:            LONGINT;
  470.             ioFlPyLen:            LONGINT;
  471.             ioFlRStBlk:            INTEGER;
  472.             ioFlRLgLen:            LONGINT;
  473.             ioFlRPyLen:            LONGINT;
  474.             ioFlCrDat:            LONGINT;
  475.             ioFlMdDat:            LONGINT;
  476.             ioFlBkDat:            LONGINT;
  477.             ioFlXFndrInfo:        FXInfo;
  478.             ioFlParID:            LONGINT;
  479.             ioFlClpSiz:            LONGINT;
  480.            );
  481.         1: (
  482.             ioDrUsrWds:            DInfo;
  483.             ioDrDirID:            LONGINT;
  484.             ioDrNmFls:            INTEGER;
  485.             filler3:            ARRAY [1..9] OF INTEGER;
  486.             ioDrCrDat:            LONGINT;
  487.             ioDrMdDat:            LONGINT;
  488.             ioDrBkDat:            LONGINT;
  489.             ioDrFndrInfo:        DXInfo;
  490.             ioDrParID:            LONGINT;
  491.            );
  492.     END;
  493.  
  494.     CInfoPBPtr                            = ^CInfoPBRec;
  495. {  Catalog position record  }
  496.     CatPositionRecPtr = ^CatPositionRec;
  497.     CatPositionRec = RECORD
  498.         initialize:                LONGINT;
  499.         priv:                    ARRAY [1..6] OF INTEGER;
  500.     END;
  501.  
  502. {$ENDC}
  503. {$IFC FOR_SYSTEM7_AND_SYSTEM8_PREEMPTIVE }
  504.  
  505. TYPE
  506.     FSSpecPtr = ^FSSpec;
  507.     FSSpec = RECORD
  508.         vRefNum:                INTEGER;
  509.         parID:                    LONGINT;
  510.         name:                    Str63;
  511.     END;
  512.  
  513.     FSSpecHandle                        = ^FSSpecPtr;
  514. {  pointer to array of FSSpecs  }
  515.     FSSpecArrayPtr                        = FSSpecPtr;
  516. {
  517.  The only difference between "const FSSpec*" and "ConstFSSpecPtr" is 
  518.    that as a parameter, ConstFSSpecPtr is allowed to be NULL 
  519. }
  520.     ConstFSSpecPtr                        = ^FSSpec;
  521. {$ENDC}
  522. {$IFC FOR_SYSTEM7_AND_SYSTEM8_DEPRECATED }
  523. {
  524.  The following are structures to be filled out with the _GetVolMountInfo call
  525.  and passed back into the _VolumeMount call for external file system mounts. 
  526. }
  527. {  the "signature" of the file system  }
  528.  
  529. TYPE
  530.     VolumeType                            = OSType;
  531.  
  532. CONST
  533.                                                                 {  the signature for AppleShare  }
  534.     AppleShareMediaType            = 'afpm';
  535.  
  536. {$IFC NOT OLDROUTINELOCATIONS }
  537.  
  538. TYPE
  539.     VolMountInfoHeaderPtr = ^VolMountInfoHeader;
  540.     VolMountInfoHeader = RECORD
  541.         length:                    INTEGER;                                {  length of location data (including self)  }
  542.         media:                    VolumeType;                                {  type of media.  Variable length data follows  }
  543.     END;
  544.  
  545.     VolMountInfoPtr                        = ^VolMountInfoHeader;
  546. {
  547.  The new volume mount info record.  The old one is included for compatibility. 
  548.     the new record allows access by foriegn filesystems writers to the flags 
  549.     portion of the record. This portion is now public.  
  550. }
  551.     VolumeMountInfoHeaderPtr = ^VolumeMountInfoHeader;
  552.     VolumeMountInfoHeader = RECORD
  553.         length:                    INTEGER;                                {  length of location data (including self)  }
  554.         media:                    VolumeType;                                {  type of media (must be registered with Apple)  }
  555.         flags:                    INTEGER;                                {  volume mount flags. Variable length data follows  }
  556.     END;
  557.  
  558. {     additional volume mount flags  }
  559.  
  560. CONST
  561.     volMountInteractBit            = 15;                            {  Input to VolumeMount: If set, it's OK for the file system  }
  562.     volMountInteractMask        = $8000;                        {  to perform user interaction to mount the volume  }
  563.     volMountChangedBit            = 14;                            {  Output from VoumeMount: If set, the volume was mounted, but  }
  564.     volMountChangedMask            = $4000;                        {  the volume mounting information record needs to be updated.  }
  565.     volMountFSReservedMask        = $00FF;                        {  bits 0-7 are defined by each file system for its own use  }
  566.     volMountSysReservedMask        = $FF00;                        {  bits 8-15 are reserved for Apple system use  }
  567.  
  568. {$ENDC}
  569.  
  570. TYPE
  571.     AFPVolMountInfoPtr = ^AFPVolMountInfo;
  572.     AFPVolMountInfo = RECORD
  573.         length:                    INTEGER;                                {  length of location data (including self)  }
  574.         media:                    VolumeType;                                {  type of media  }
  575.         flags:                    INTEGER;                                {  bits for no messages, no reconnect  }
  576.         nbpInterval:            SInt8;                                    {  NBP Interval parameter (IM2, p.322)  }
  577.         nbpCount:                SInt8;                                    {  NBP Interval parameter (IM2, p.322)  }
  578.         uamType:                INTEGER;                                {  User Authentication Method  }
  579.         zoneNameOffset:            INTEGER;                                {  short positive offset from start of struct to Zone Name  }
  580.         serverNameOffset:        INTEGER;                                {  offset to pascal Server Name string  }
  581.         volNameOffset:            INTEGER;                                {  offset to pascal Volume Name string  }
  582.         userNameOffset:            INTEGER;                                {  offset to pascal User Name string  }
  583.         userPasswordOffset:        INTEGER;                                {  offset to pascal User Password string  }
  584.         volPasswordOffset:        INTEGER;                                {  offset to pascal Volume Password string  }
  585.         AFPData:                PACKED ARRAY [1..144] OF CHAR;            {  variable length data may follow  }
  586.     END;
  587.  
  588.     DTPBRecPtr = ^DTPBRec;
  589.     DTPBRec = RECORD
  590.         qLink:                    QElemPtr;                                { queue link in header }
  591.         qType:                    INTEGER;                                { type byte for safety check }
  592.         ioTrap:                    INTEGER;                                { FS: the Trap }
  593.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  594.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  595.         ioResult:                OSErr;                                    { result code }
  596.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  597.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  598.         ioDTRefNum:                INTEGER;                                {  desktop refnum  }
  599.         ioIndex:                INTEGER;
  600.         ioTagInfo:                LONGINT;
  601.         ioDTBuffer:                Ptr;
  602.         ioDTReqCount:            LONGINT;
  603.         ioDTActCount:            LONGINT;
  604.         ioFiller1:                SInt8;
  605.         ioIconType:                SInt8;
  606.         ioFiller2:                INTEGER;
  607.         ioDirID:                LONGINT;
  608.         ioFileCreator:            OSType;
  609.         ioFileType:                OSType;
  610.         ioFiller3:                LONGINT;
  611.         ioDTLgLen:                LONGINT;
  612.         ioDTPyLen:                LONGINT;
  613.         ioFiller4:                ARRAY [1..14] OF INTEGER;
  614.         ioAPPLParID:            LONGINT;
  615.     END;
  616.  
  617.     DTPBPtr                                = ^DTPBRec;
  618.     HIOParamPtr = ^HIOParam;
  619.     HIOParam = RECORD
  620.         qLink:                    QElemPtr;                                { queue link in header }
  621.         qType:                    INTEGER;                                { type byte for safety check }
  622.         ioTrap:                    INTEGER;                                { FS: the Trap }
  623.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  624.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  625.         ioResult:                OSErr;                                    { result code }
  626.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  627.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  628.         ioRefNum:                INTEGER;
  629.         ioVersNum:                SInt8;
  630.         ioPermssn:                SInt8;
  631.         ioMisc:                    Ptr;
  632.         ioBuffer:                Ptr;
  633.         ioReqCount:                LONGINT;
  634.         ioActCount:                LONGINT;
  635.         ioPosMode:                INTEGER;
  636.         ioPosOffset:            LONGINT;
  637.     END;
  638.  
  639.     HFileParamPtr = ^HFileParam;
  640.     HFileParam = RECORD
  641.         qLink:                    QElemPtr;                                { queue link in header }
  642.         qType:                    INTEGER;                                { type byte for safety check }
  643.         ioTrap:                    INTEGER;                                { FS: the Trap }
  644.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  645.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  646.         ioResult:                OSErr;                                    { result code }
  647.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  648.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  649.         ioFRefNum:                INTEGER;
  650.         ioFVersNum:                SInt8;
  651.         filler1:                SInt8;
  652.         ioFDirIndex:            INTEGER;
  653.         ioFlAttrib:                SInt8;
  654.         ioFlVersNum:            SInt8;
  655.         ioFlFndrInfo:            FInfo;
  656.         ioDirID:                LONGINT;
  657.         ioFlStBlk:                INTEGER;
  658.         ioFlLgLen:                LONGINT;
  659.         ioFlPyLen:                LONGINT;
  660.         ioFlRStBlk:                INTEGER;
  661.         ioFlRLgLen:                LONGINT;
  662.         ioFlRPyLen:                LONGINT;
  663.         ioFlCrDat:                LONGINT;
  664.         ioFlMdDat:                LONGINT;
  665.     END;
  666.  
  667.     HVolumeParamPtr = ^HVolumeParam;
  668.     HVolumeParam = RECORD
  669.         qLink:                    QElemPtr;                                { queue link in header }
  670.         qType:                    INTEGER;                                { type byte for safety check }
  671.         ioTrap:                    INTEGER;                                { FS: the Trap }
  672.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  673.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  674.         ioResult:                OSErr;                                    { result code }
  675.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  676.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  677.         filler2:                LONGINT;
  678.         ioVolIndex:                INTEGER;
  679.         ioVCrDate:                LONGINT;
  680.         ioVLsMod:                LONGINT;
  681.         ioVAtrb:                INTEGER;
  682.         ioVNmFls:                INTEGER;
  683.         ioVBitMap:                INTEGER;
  684.         ioAllocPtr:                INTEGER;
  685.         ioVNmAlBlks:            INTEGER;
  686.         ioVAlBlkSiz:            LONGINT;
  687.         ioVClpSiz:                LONGINT;
  688.         ioAlBlSt:                INTEGER;
  689.         ioVNxtCNID:                LONGINT;
  690.         ioVFrBlk:                INTEGER;
  691.         ioVSigWord:                INTEGER;
  692.         ioVDrvInfo:                INTEGER;
  693.         ioVDRefNum:                INTEGER;
  694.         ioVFSID:                INTEGER;
  695.         ioVBkUp:                LONGINT;
  696.         ioVSeqNum:                INTEGER;
  697.         ioVWrCnt:                LONGINT;
  698.         ioVFilCnt:                LONGINT;
  699.         ioVDirCnt:                LONGINT;
  700.         ioVFndrInfo:            ARRAY [1..8] OF LONGINT;
  701.     END;
  702.  
  703.  
  704. CONST
  705.                                                                 {  Large Volume Constants  }
  706.     kWidePosOffsetBit            = 8;
  707.     kMaximumBlocksIn4GB            = $007FFFFF;
  708.  
  709.  
  710. TYPE
  711.     XIOParamPtr = ^XIOParam;
  712.     XIOParam = RECORD
  713.         qLink:                    QElemPtr;
  714.         qType:                    INTEGER;
  715.         ioTrap:                    INTEGER;
  716.         ioCmdAddr:                Ptr;
  717.         ioCompletion:            IOCompletionUPP;
  718.         ioResult:                OSErr;
  719.         ioNamePtr:                StringPtr;
  720.         ioVRefNum:                INTEGER;
  721.         ioRefNum:                INTEGER;
  722.         ioVersNum:                SInt8;
  723.         ioPermssn:                SInt8;
  724.         ioMisc:                    Ptr;
  725.         ioBuffer:                Ptr;
  726.         ioReqCount:                LONGINT;
  727.         ioActCount:                LONGINT;
  728.         ioPosMode:                INTEGER;                                {  must have kUseWidePositioning bit set  }
  729.         ioWPosOffset:            wide;                                    {  wide positioning offset  }
  730.     END;
  731.  
  732.     XVolumeParamPtr = ^XVolumeParam;
  733.     XVolumeParam = RECORD
  734.         qLink:                    QElemPtr;
  735.         qType:                    INTEGER;
  736.         ioTrap:                    INTEGER;
  737.         ioCmdAddr:                Ptr;
  738.         ioCompletion:            IOCompletionUPP;
  739.         ioResult:                OSErr;
  740.         ioNamePtr:                StringPtr;
  741.         ioVRefNum:                INTEGER;
  742.         ioXVersion:                LONGINT;                                {  this XVolumeParam version (0)  }
  743.         ioVolIndex:                INTEGER;
  744.         ioVCrDate:                LONGINT;
  745.         ioVLsMod:                LONGINT;
  746.         ioVAtrb:                INTEGER;
  747.         ioVNmFls:                INTEGER;
  748.         ioVBitMap:                INTEGER;
  749.         ioAllocPtr:                INTEGER;
  750.         ioVNmAlBlks:            INTEGER;
  751.         ioVAlBlkSiz:            LONGINT;
  752.         ioVClpSiz:                LONGINT;
  753.         ioAlBlSt:                INTEGER;
  754.         ioVNxtCNID:                LONGINT;
  755.         ioVFrBlk:                INTEGER;
  756.         ioVSigWord:                INTEGER;
  757.         ioVDrvInfo:                INTEGER;
  758.         ioVDRefNum:                INTEGER;
  759.         ioVFSID:                INTEGER;
  760.         ioVBkUp:                LONGINT;
  761.         ioVSeqNum:                INTEGER;
  762.         ioVWrCnt:                LONGINT;
  763.         ioVFilCnt:                LONGINT;
  764.         ioVDirCnt:                LONGINT;
  765.         ioVFndrInfo:            ARRAY [1..8] OF LONGINT;
  766.         ioVTotalBytes:            UnsignedWide;                            {  total number of bytes on volume  }
  767.         ioVFreeBytes:            UnsignedWide;                            {  number of free bytes on volume  }
  768.     END;
  769.  
  770.     AccessParamPtr = ^AccessParam;
  771.     AccessParam = RECORD
  772.         qLink:                    QElemPtr;                                { queue link in header }
  773.         qType:                    INTEGER;                                { type byte for safety check }
  774.         ioTrap:                    INTEGER;                                { FS: the Trap }
  775.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  776.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  777.         ioResult:                OSErr;                                    { result code }
  778.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  779.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  780.         filler3:                INTEGER;
  781.         ioDenyModes:            INTEGER;                                { access rights data }
  782.         filler4:                INTEGER;
  783.         filler5:                SInt8;
  784.         ioACUser:                SInt8;                                    { access rights for directory only }
  785.         filler6:                LONGINT;
  786.         ioACOwnerID:            LONGINT;                                { owner ID }
  787.         ioACGroupID:            LONGINT;                                { group ID }
  788.         ioACAccess:                LONGINT;                                { access rights }
  789.         ioDirID:                LONGINT;
  790.     END;
  791.  
  792.     ObjParamPtr = ^ObjParam;
  793.     ObjParam = RECORD
  794.         qLink:                    QElemPtr;                                { queue link in header }
  795.         qType:                    INTEGER;                                { type byte for safety check }
  796.         ioTrap:                    INTEGER;                                { FS: the Trap }
  797.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  798.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  799.         ioResult:                OSErr;                                    { result code }
  800.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  801.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  802.         filler7:                INTEGER;
  803.         ioObjType:                INTEGER;                                { function code }
  804.         ioObjNamePtr:            StringPtr;                                { ptr to returned creator/group name }
  805.         ioObjID:                LONGINT;                                { creator/group ID }
  806.     END;
  807.  
  808.     CopyParamPtr = ^CopyParam;
  809.     CopyParam = RECORD
  810.         qLink:                    QElemPtr;                                { queue link in header }
  811.         qType:                    INTEGER;                                { type byte for safety check }
  812.         ioTrap:                    INTEGER;                                { FS: the Trap }
  813.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  814.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  815.         ioResult:                OSErr;                                    { result code }
  816.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  817.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  818.         ioDstVRefNum:            INTEGER;                                { destination vol identifier }
  819.         filler8:                INTEGER;
  820.         ioNewName:                StringPtr;                                { ptr to destination pathname }
  821.         ioCopyName:                StringPtr;                                { ptr to optional name }
  822.         ioNewDirID:                LONGINT;                                { destination directory ID }
  823.         filler14:                LONGINT;
  824.         filler15:                LONGINT;
  825.         ioDirID:                LONGINT;
  826.     END;
  827.  
  828.     WDParamPtr = ^WDParam;
  829.     WDParam = RECORD
  830.         qLink:                    QElemPtr;                                { queue link in header }
  831.         qType:                    INTEGER;                                { type byte for safety check }
  832.         ioTrap:                    INTEGER;                                { FS: the Trap }
  833.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  834.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  835.         ioResult:                OSErr;                                    { result code }
  836.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  837.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  838.         filler9:                INTEGER;
  839.         ioWDIndex:                INTEGER;
  840.         ioWDProcID:                LONGINT;
  841.         ioWDVRefNum:            INTEGER;
  842.         filler10:                INTEGER;
  843.         filler11:                LONGINT;
  844.         filler12:                LONGINT;
  845.         filler13:                LONGINT;
  846.         ioWDDirID:                LONGINT;
  847.     END;
  848.  
  849.     FIDParamPtr = ^FIDParam;
  850.     FIDParam = RECORD
  851.         qLink:                    QElemPtr;                                { queue link in header }
  852.         qType:                    INTEGER;                                { type byte for safety check }
  853.         ioTrap:                    INTEGER;                                { FS: the Trap }
  854.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  855.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  856.         ioResult:                OSErr;                                    { result code }
  857.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  858.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  859.         filler14:                LONGINT;
  860.         ioDestNamePtr:            StringPtr;                                {  dest file name  }
  861.         filler15:                LONGINT;
  862.         ioDestDirID:            LONGINT;                                {  dest file's directory id  }
  863.         filler16:                LONGINT;
  864.         filler17:                LONGINT;
  865.         ioSrcDirID:                LONGINT;                                {  source file's directory id  }
  866.         filler18:                INTEGER;
  867.         ioFileID:                LONGINT;                                {  file ID  }
  868.     END;
  869.  
  870.     ForeignPrivParamPtr = ^ForeignPrivParam;
  871.     ForeignPrivParam = RECORD
  872.         qLink:                    QElemPtr;                                { queue link in header }
  873.         qType:                    INTEGER;                                { type byte for safety check }
  874.         ioTrap:                    INTEGER;                                { FS: the Trap }
  875.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  876.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  877.         ioResult:                OSErr;                                    { result code }
  878.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  879.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  880.         ioFiller21:                LONGINT;
  881.         ioFiller22:                LONGINT;
  882.         ioForeignPrivBuffer:    Ptr;
  883.         ioForeignPrivActCount:    LONGINT;
  884.         ioForeignPrivReqCount:    LONGINT;
  885.         ioFiller23:                LONGINT;
  886.         ioForeignPrivDirID:        LONGINT;
  887.         ioForeignPrivInfo1:        LONGINT;
  888.         ioForeignPrivInfo2:        LONGINT;
  889.         ioForeignPrivInfo3:        LONGINT;
  890.         ioForeignPrivInfo4:        LONGINT;
  891.     END;
  892.  
  893.     CSParamPtr = ^CSParam;
  894.     CSParam = RECORD
  895.         qLink:                    QElemPtr;                                { queue link in header }
  896.         qType:                    INTEGER;                                { type byte for safety check }
  897.         ioTrap:                    INTEGER;                                { FS: the Trap }
  898.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  899.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  900.         ioResult:                OSErr;                                    { result code }
  901.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  902.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  903.         ioMatchPtr:                FSSpecPtr;                                {  match array  }
  904.         ioReqMatchCount:        LONGINT;                                {  maximum allowable matches  }
  905.         ioActMatchCount:        LONGINT;                                {  actual match count  }
  906.         ioSearchBits:            LONGINT;                                {  search criteria selector  }
  907.         ioSearchInfo1:            CInfoPBPtr;                                {  search values and range lower bounds  }
  908.         ioSearchInfo2:            CInfoPBPtr;                                {  search values and range upper bounds  }
  909.         ioSearchTime:            LONGINT;                                {  length of time to run search  }
  910.         ioCatPosition:            CatPositionRec;                            {  current position in the catalog  }
  911.         ioOptBuffer:            Ptr;                                    {  optional performance enhancement buffer  }
  912.         ioOptBufSize:            LONGINT;                                {  size of buffer pointed to by ioOptBuffer  }
  913.     END;
  914.  
  915.     HParamBlockRecPtr = ^HParamBlockRec;
  916.     HParamBlockRec = RECORD
  917.         qLink:                    QElemPtr;                                { queue link in header }
  918.         qType:                    INTEGER;                                { type byte for safety check }
  919.         ioTrap:                    INTEGER;                                { FS: the Trap }
  920.         ioCmdAddr:                Ptr;                                    { FS: address to dispatch to }
  921.         ioCompletion:            IOCompletionUPP;                        { completion routine addr (0 for synch calls) }
  922.         ioResult:                OSErr;                                    { result code }
  923.         ioNamePtr:                StringPtr;                                { ptr to Vol:FileName string }
  924.         ioVRefNum:                INTEGER;                                { volume refnum (DrvNum for Eject and MountVol) }
  925.         CASE INTEGER OF
  926.         0: (
  927.             ioRefNum:            INTEGER;
  928.             ioVersNum:            SInt8;
  929.             ioPermssn:            SInt8;
  930.             ioMisc:                Ptr;
  931.             ioBuffer:            Ptr;
  932.             ioReqCount:            LONGINT;
  933.             ioActCount:            LONGINT;
  934.             ioPosMode:            INTEGER;
  935.             ioPosOffset:        LONGINT;
  936.            );
  937.         1: (
  938.             ioFRefNum:            INTEGER;
  939.             ioFVersNum:            SInt8;
  940.             filler1:            SInt8;
  941.             ioFDirIndex:        INTEGER;
  942.             ioFlAttrib:            SInt8;
  943.             ioFlVersNum:        SInt8;
  944.             ioFlFndrInfo:        FInfo;
  945.             ioDirID:            LONGINT;
  946.             ioFlStBlk:            INTEGER;
  947.             ioFlLgLen:            LONGINT;
  948.             ioFlPyLen:            LONGINT;
  949.             ioFlRStBlk:            INTEGER;
  950.             ioFlRLgLen:            LONGINT;
  951.             ioFlRPyLen:            LONGINT;
  952.             ioFlCrDat:            LONGINT;
  953.             ioFlMdDat:            LONGINT;
  954.            );
  955.         2: (
  956.             filler2:            LONGINT;
  957.             ioVolIndex:            INTEGER;
  958.             ioVCrDate:            LONGINT;
  959.             ioVLsMod:            LONGINT;
  960.             ioVAtrb:            INTEGER;
  961.             ioVNmFls:            INTEGER;
  962.             ioVBitMap:            INTEGER;
  963.             ioAllocPtr:            INTEGER;
  964.             ioVNmAlBlks:        INTEGER;
  965.             ioVAlBlkSiz:        LONGINT;
  966.             ioVClpSiz:            LONGINT;
  967.             ioAlBlSt:            INTEGER;
  968.             ioVNxtCNID:            LONGINT;
  969.             ioVFrBlk:            INTEGER;
  970.             ioVSigWord:            INTEGER;
  971.             ioVDrvInfo:            INTEGER;
  972.             ioVDRefNum:            INTEGER;
  973.             ioVFSID:            INTEGER;
  974.             ioVBkUp:            LONGINT;
  975.             ioVSeqNum:            INTEGER;
  976.             ioVWrCnt:            LONGINT;
  977.             ioVFilCnt:            LONGINT;
  978.             ioVDirCnt:            LONGINT;
  979.             ioVFndrInfo:        ARRAY [1..8] OF LONGINT;
  980.            );
  981.         3: (
  982.             filler3:            INTEGER;
  983.             ioDenyModes:        INTEGER;                                { access rights data }
  984.             filler4:            INTEGER;
  985.             filler5:            SInt8;
  986.             ioACUser:            SInt8;                                    { access rights for directory only }
  987.             filler6:            LONGINT;
  988.             ioACOwnerID:        LONGINT;                                { owner ID }
  989.             ioACGroupID:        LONGINT;                                { group ID }
  990.             ioACAccess:            LONGINT;                                { access rights }
  991.            );
  992.         4: (
  993.             filler7:            INTEGER;
  994.             ioObjType:            INTEGER;                                { function code }
  995.             ioObjNamePtr:        StringPtr;                                { ptr to returned creator/group name }
  996.             ioObjID:            LONGINT;                                { creator/group ID }
  997.            );
  998.         5: (
  999.             ioDstVRefNum:        INTEGER;                                { destination vol identifier }
  1000.             filler8:            INTEGER;
  1001.             ioNewName:            StringPtr;                                { ptr to destination pathname }
  1002.             ioCopyName:            StringPtr;                                { ptr to optional name }
  1003.             ioNewDirID:            LONGINT;                                { destination directory ID }
  1004.            );
  1005.         6: (
  1006.             filler9:            INTEGER;
  1007.             ioWDIndex:            INTEGER;
  1008.             ioWDProcID:            LONGINT;
  1009.             ioWDVRefNum:        INTEGER;
  1010.             filler10:            INTEGER;
  1011.             filler11:            LONGINT;
  1012.             filler12:            LONGINT;
  1013.             filler13:            LONGINT;
  1014.             ioWDDirID:            LONGINT;
  1015.            );
  1016.         7: (
  1017.             filler14:            LONGINT;
  1018.             ioDestNamePtr:        StringPtr;                                {  dest file name  }
  1019.             filler15:            LONGINT;
  1020.             ioDestDirID:        LONGINT;                                {  dest file's directory id  }
  1021.             filler16:            LONGINT;
  1022.             filler17:            LONGINT;
  1023.             ioSrcDirID:            LONGINT;                                {  source file's directory id  }
  1024.             filler18:            INTEGER;
  1025.             ioFileID:            LONGINT;                                {  file ID  }
  1026.            );
  1027.         8: (
  1028.             ioMatchPtr:            FSSpecPtr;                                {  match array  }
  1029.             ioReqMatchCount:    LONGINT;                                {  maximum allowable matches  }
  1030.             ioActMatchCount:    LONGINT;                                {  actual match count  }
  1031.             ioSearchBits:        LONGINT;                                {  search criteria selector  }
  1032.             ioSearchInfo1:        CInfoPBPtr;                                {  search values and range lower bounds  }
  1033.             ioSearchInfo2:        CInfoPBPtr;                                {  search values and range upper bounds  }
  1034.             ioSearchTime:        LONGINT;                                {  length of time to run search  }
  1035.             ioCatPosition:        CatPositionRec;                            {  current position in the catalog  }
  1036.             ioOptBuffer:        Ptr;                                    {  optional performance enhancement buffer  }
  1037.             ioOptBufSize:        LONGINT;                                {  size of buffer pointed to by ioOptBuffer  }
  1038.            );
  1039.         9: (
  1040.             ioFiller21:            LONGINT;
  1041.             ioFiller22:            LONGINT;
  1042.             ioForeignPrivBuffer: Ptr;
  1043.             ioForeignPrivActCount: LONGINT;
  1044.             ioForeignPrivReqCount: LONGINT;
  1045.             ioFiller23:            LONGINT;
  1046.             ioForeignPrivDirID:    LONGINT;
  1047.             ioForeignPrivInfo1:    LONGINT;
  1048.             ioForeignPrivInfo2:    LONGINT;
  1049.             ioForeignPrivInfo3:    LONGINT;
  1050.             ioForeignPrivInfo4:    LONGINT;
  1051.            );
  1052.     END;
  1053.  
  1054.     HParmBlkPtr                            = ^HParamBlockRec;
  1055.     CMovePBRecPtr = ^CMovePBRec;
  1056.     CMovePBRec = RECORD
  1057.         qLink:                    QElemPtr;
  1058.         qType:                    INTEGER;
  1059.         ioTrap:                    INTEGER;
  1060.         ioCmdAddr:                Ptr;
  1061.         ioCompletion:            IOCompletionUPP;
  1062.         ioResult:                OSErr;
  1063.         ioNamePtr:                StringPtr;
  1064.         ioVRefNum:                INTEGER;
  1065.         filler1:                LONGINT;
  1066.         ioNewName:                StringPtr;
  1067.         filler2:                LONGINT;
  1068.         ioNewDirID:                LONGINT;
  1069.         filler3:                ARRAY [1..2] OF LONGINT;
  1070.         ioDirID:                LONGINT;
  1071.     END;
  1072.  
  1073.     CMovePBPtr                            = ^CMovePBRec;
  1074.     WDPBRecPtr = ^WDPBRec;
  1075.     WDPBRec = RECORD
  1076.         qLink:                    QElemPtr;
  1077.         qType:                    INTEGER;
  1078.         ioTrap:                    INTEGER;
  1079.         ioCmdAddr:                Ptr;
  1080.         ioCompletion:            IOCompletionUPP;
  1081.         ioResult:                OSErr;
  1082.         ioNamePtr:                StringPtr;
  1083.         ioVRefNum:                INTEGER;
  1084.         filler1:                INTEGER;
  1085.         ioWDIndex:                INTEGER;
  1086.         ioWDProcID:                LONGINT;
  1087.         ioWDVRefNum:            INTEGER;
  1088.         filler2:                ARRAY [1..7] OF INTEGER;
  1089.         ioWDDirID:                LONGINT;
  1090.     END;
  1091.  
  1092.     WDPBPtr                                = ^WDPBRec;
  1093.     FCBPBRecPtr = ^FCBPBRec;
  1094.     FCBPBRec = RECORD
  1095.         qLink:                    QElemPtr;
  1096.         qType:                    INTEGER;
  1097.         ioTrap:                    INTEGER;
  1098.         ioCmdAddr:                Ptr;
  1099.         ioCompletion:            IOCompletionUPP;
  1100.         ioResult:                OSErr;
  1101.         ioNamePtr:                StringPtr;
  1102.         ioVRefNum:                INTEGER;
  1103.         ioRefNum:                INTEGER;
  1104.         filler:                    INTEGER;
  1105.         ioFCBIndx:                INTEGER;
  1106.         filler1:                INTEGER;
  1107.         ioFCBFlNm:                LONGINT;
  1108.         ioFCBFlags:                INTEGER;
  1109.         ioFCBStBlk:                INTEGER;
  1110.         ioFCBEOF:                LONGINT;
  1111.         ioFCBPLen:                LONGINT;
  1112.         ioFCBCrPs:                LONGINT;
  1113.         ioFCBVRefNum:            INTEGER;
  1114.         ioFCBClpSiz:            LONGINT;
  1115.         ioFCBParID:                LONGINT;
  1116.     END;
  1117.  
  1118.     FCBPBPtr                            = ^FCBPBRec;
  1119.     VCBPtr = ^VCB;
  1120.     VCB = RECORD
  1121.         qLink:                    QElemPtr;
  1122.         qType:                    INTEGER;
  1123.         vcbFlags:                INTEGER;
  1124.         vcbSigWord:                INTEGER;
  1125.         vcbCrDate:                LONGINT;
  1126.         vcbLsMod:                LONGINT;
  1127.         vcbAtrb:                INTEGER;
  1128.         vcbNmFls:                INTEGER;
  1129.         vcbVBMSt:                INTEGER;
  1130.         vcbAllocPtr:            INTEGER;
  1131.         vcbNmAlBlks:            INTEGER;
  1132.         vcbAlBlkSiz:            LONGINT;
  1133.         vcbClpSiz:                LONGINT;
  1134.         vcbAlBlSt:                INTEGER;
  1135.         vcbNxtCNID:                LONGINT;
  1136.         vcbFreeBks:                INTEGER;
  1137.         vcbVN:                    Str27;
  1138.         vcbDrvNum:                INTEGER;
  1139.         vcbDRefNum:                INTEGER;
  1140.         vcbFSID:                INTEGER;
  1141.         vcbVRefNum:                INTEGER;
  1142.         vcbMAdr:                Ptr;
  1143.         vcbBufAdr:                Ptr;
  1144.         vcbMLen:                INTEGER;
  1145.         vcbDirIndex:            INTEGER;
  1146.         vcbDirBlk:                INTEGER;
  1147.         vcbVolBkUp:                LONGINT;
  1148.         vcbVSeqNum:                INTEGER;
  1149.         vcbWrCnt:                LONGINT;
  1150.         vcbXTClpSiz:            LONGINT;
  1151.         vcbCTClpSiz:            LONGINT;
  1152.         vcbNmRtDirs:            INTEGER;
  1153.         vcbFilCnt:                LONGINT;
  1154.         vcbDirCnt:                LONGINT;
  1155.         vcbFndrInfo:            ARRAY [1..8] OF LONGINT;
  1156.         vcbVCSize:                INTEGER;
  1157.         vcbVBMCSiz:                INTEGER;
  1158.         vcbCtlCSiz:                INTEGER;
  1159.         vcbXTAlBlks:            INTEGER;
  1160.         vcbCTAlBlks:            INTEGER;
  1161.         vcbXTRef:                INTEGER;
  1162.         vcbCTRef:                INTEGER;
  1163.         vcbCtlBuf:                Ptr;
  1164.         vcbDirIDM:                LONGINT;
  1165.         vcbOffsM:                INTEGER;
  1166.     END;
  1167.  
  1168. {$IFC NOT OLDROUTINELOCATIONS }
  1169. {$ENDC}
  1170.     DrvQElPtr = ^DrvQEl;
  1171.     DrvQEl = RECORD
  1172.         qLink:                    QElemPtr;
  1173.         qType:                    INTEGER;
  1174.         dQDrive:                INTEGER;
  1175.         dQRefNum:                INTEGER;
  1176.         dQFSID:                    INTEGER;
  1177.         dQDrvSz:                INTEGER;
  1178.         dQDrvSz2:                INTEGER;
  1179.     END;
  1180.  
  1181.  
  1182. CONST
  1183.     uppIOCompletionProcInfo = $00009802;
  1184.  
  1185. FUNCTION NewIOCompletionProc(userRoutine: IOCompletionProcPtr): IOCompletionUPP;
  1186.     {$IFC NOT GENERATINGCFM }
  1187.     INLINE $2E9F;
  1188.     {$ENDC}
  1189.  
  1190. PROCEDURE CallIOCompletionProc(paramBlock: ParmBlkPtr; userRoutine: IOCompletionUPP);
  1191.     {$IFC NOT GENERATINGCFM}
  1192.     {To be implemented:  Glue to move parameters into registers.}
  1193.     {$ENDC}
  1194. {$IFC OLDROUTINELOCATIONS }
  1195. FUNCTION PBOpenSync(paramBlock: ParmBlkPtr): OSErr;
  1196.     {$IFC NOT GENERATINGCFM}
  1197.     INLINE $205F, $A000, $3E80;
  1198.     {$ENDC}
  1199. FUNCTION PBOpenAsync(paramBlock: ParmBlkPtr): OSErr;
  1200.     {$IFC NOT GENERATINGCFM}
  1201.     INLINE $205F, $A400, $3E80;
  1202.     {$ENDC}
  1203. FUNCTION PBOpenImmed(paramBlock: ParmBlkPtr): OSErr;
  1204.     {$IFC NOT GENERATINGCFM}
  1205.     INLINE $205F, $A200, $3E80;
  1206.     {$ENDC}
  1207. FUNCTION PBCloseSync(paramBlock: ParmBlkPtr): OSErr;
  1208.     {$IFC NOT GENERATINGCFM}
  1209.     INLINE $205F, $A001, $3E80;
  1210.     {$ENDC}
  1211. FUNCTION PBCloseAsync(paramBlock: ParmBlkPtr): OSErr;
  1212.     {$IFC NOT GENERATINGCFM}
  1213.     INLINE $205F, $A401, $3E80;
  1214.     {$ENDC}
  1215. FUNCTION PBCloseImmed(paramBlock: ParmBlkPtr): OSErr;
  1216.     {$IFC NOT GENERATINGCFM}
  1217.     INLINE $205F, $A201, $3E80;
  1218.     {$ENDC}
  1219. FUNCTION PBReadSync(paramBlock: ParmBlkPtr): OSErr;
  1220.     {$IFC NOT GENERATINGCFM}
  1221.     INLINE $205F, $A002, $3E80;
  1222.     {$ENDC}
  1223. FUNCTION PBReadAsync(paramBlock: ParmBlkPtr): OSErr;
  1224.     {$IFC NOT GENERATINGCFM}
  1225.     INLINE $205F, $A402, $3E80;
  1226.     {$ENDC}
  1227. FUNCTION PBReadImmed(paramBlock: ParmBlkPtr): OSErr;
  1228.     {$IFC NOT GENERATINGCFM}
  1229.     INLINE $205F, $A202, $3E80;
  1230.     {$ENDC}
  1231. FUNCTION PBWriteSync(paramBlock: ParmBlkPtr): OSErr;
  1232.     {$IFC NOT GENERATINGCFM}
  1233.     INLINE $205F, $A003, $3E80;
  1234.     {$ENDC}
  1235. FUNCTION PBWriteAsync(paramBlock: ParmBlkPtr): OSErr;
  1236.     {$IFC NOT GENERATINGCFM}
  1237.     INLINE $205F, $A403, $3E80;
  1238.     {$ENDC}
  1239. FUNCTION PBWriteImmed(paramBlock: ParmBlkPtr): OSErr;
  1240.     {$IFC NOT GENERATINGCFM}
  1241.     INLINE $205F, $A203, $3E80;
  1242.     {$ENDC}
  1243. {$ENDC}
  1244. FUNCTION PBGetVInfoSync(paramBlock: ParmBlkPtr): OSErr;
  1245.     {$IFC NOT GENERATINGCFM}
  1246.     INLINE $205F, $A007, $3E80;
  1247.     {$ENDC}
  1248. FUNCTION PBGetVInfoAsync(paramBlock: ParmBlkPtr): OSErr;
  1249.     {$IFC NOT GENERATINGCFM}
  1250.     INLINE $205F, $A407, $3E80;
  1251.     {$ENDC}
  1252. FUNCTION PBXGetVolInfoSync(paramBlock: XVolumeParamPtr): OSErr;
  1253.     {$IFC NOT GENERATINGCFM}
  1254.     INLINE $205F, $7012, $A060, $3E80;
  1255.     {$ENDC}
  1256. FUNCTION PBXGetVolInfoAsync(paramBlock: XVolumeParamPtr): OSErr;
  1257.     {$IFC NOT GENERATINGCFM}
  1258.     INLINE $205F, $7012, $A460, $3E80;
  1259.     {$ENDC}
  1260. FUNCTION PBGetVolSync(paramBlock: ParmBlkPtr): OSErr;
  1261.     {$IFC NOT GENERATINGCFM}
  1262.     INLINE $205F, $A014, $3E80;
  1263.     {$ENDC}
  1264. FUNCTION PBGetVolAsync(paramBlock: ParmBlkPtr): OSErr;
  1265.     {$IFC NOT GENERATINGCFM}
  1266.     INLINE $205F, $A414, $3E80;
  1267.     {$ENDC}
  1268. FUNCTION PBSetVolSync(paramBlock: ParmBlkPtr): OSErr;
  1269.     {$IFC NOT GENERATINGCFM}
  1270.     INLINE $205F, $A015, $3E80;
  1271.     {$ENDC}
  1272. FUNCTION PBSetVolAsync(paramBlock: ParmBlkPtr): OSErr;
  1273.     {$IFC NOT GENERATINGCFM}
  1274.     INLINE $205F, $A415, $3E80;
  1275.     {$ENDC}
  1276. FUNCTION PBFlushVolSync(paramBlock: ParmBlkPtr): OSErr;
  1277.     {$IFC NOT GENERATINGCFM}
  1278.     INLINE $205F, $A013, $3E80;
  1279.     {$ENDC}
  1280. FUNCTION PBFlushVolAsync(paramBlock: ParmBlkPtr): OSErr;
  1281.     {$IFC NOT GENERATINGCFM}
  1282.     INLINE $205F, $A413, $3E80;
  1283.     {$ENDC}
  1284. FUNCTION PBCreateSync(paramBlock: ParmBlkPtr): OSErr;
  1285.     {$IFC NOT GENERATINGCFM}
  1286.     INLINE $205F, $A008, $3E80;
  1287.     {$ENDC}
  1288. FUNCTION PBCreateAsync(paramBlock: ParmBlkPtr): OSErr;
  1289.     {$IFC NOT GENERATINGCFM}
  1290.     INLINE $205F, $A408, $3E80;
  1291.     {$ENDC}
  1292. FUNCTION PBDeleteSync(paramBlock: ParmBlkPtr): OSErr;
  1293.     {$IFC NOT GENERATINGCFM}
  1294.     INLINE $205F, $A009, $3E80;
  1295.     {$ENDC}
  1296. FUNCTION PBDeleteAsync(paramBlock: ParmBlkPtr): OSErr;
  1297.     {$IFC NOT GENERATINGCFM}
  1298.     INLINE $205F, $A409, $3E80;
  1299.     {$ENDC}
  1300. FUNCTION PBOpenDFSync(paramBlock: ParmBlkPtr): OSErr;
  1301.     {$IFC NOT GENERATINGCFM}
  1302.     INLINE $205F, $701A, $A060, $3E80;
  1303.     {$ENDC}
  1304. FUNCTION PBOpenDFAsync(paramBlock: ParmBlkPtr): OSErr;
  1305.     {$IFC NOT GENERATINGCFM}
  1306.     INLINE $205F, $701A, $A460, $3E80;
  1307.     {$ENDC}
  1308. FUNCTION PBOpenRFSync(paramBlock: ParmBlkPtr): OSErr;
  1309.     {$IFC NOT GENERATINGCFM}
  1310.     INLINE $205F, $A00A, $3E80;
  1311.     {$ENDC}
  1312. FUNCTION PBOpenRFAsync(paramBlock: ParmBlkPtr): OSErr;
  1313.     {$IFC NOT GENERATINGCFM}
  1314.     INLINE $205F, $A40A, $3E80;
  1315.     {$ENDC}
  1316. FUNCTION PBRenameSync(paramBlock: ParmBlkPtr): OSErr;
  1317.     {$IFC NOT GENERATINGCFM}
  1318.     INLINE $205F, $A00B, $3E80;
  1319.     {$ENDC}
  1320. FUNCTION PBRenameAsync(paramBlock: ParmBlkPtr): OSErr;
  1321.     {$IFC NOT GENERATINGCFM}
  1322.     INLINE $205F, $A40B, $3E80;
  1323.     {$ENDC}
  1324. FUNCTION PBGetFInfoSync(paramBlock: ParmBlkPtr): OSErr;
  1325.     {$IFC NOT GENERATINGCFM}
  1326.     INLINE $205F, $A00C, $3E80;
  1327.     {$ENDC}
  1328. FUNCTION PBGetFInfoAsync(paramBlock: ParmBlkPtr): OSErr;
  1329.     {$IFC NOT GENERATINGCFM}
  1330.     INLINE $205F, $A40C, $3E80;
  1331.     {$ENDC}
  1332. FUNCTION PBSetFInfoSync(paramBlock: ParmBlkPtr): OSErr;
  1333.     {$IFC NOT GENERATINGCFM}
  1334.     INLINE $205F, $A00D, $3E80;
  1335.     {$ENDC}
  1336. FUNCTION PBSetFInfoAsync(paramBlock: ParmBlkPtr): OSErr;
  1337.     {$IFC NOT GENERATINGCFM}
  1338.     INLINE $205F, $A40D, $3E80;
  1339.     {$ENDC}
  1340. FUNCTION PBSetFLockSync(paramBlock: ParmBlkPtr): OSErr;
  1341.     {$IFC NOT GENERATINGCFM}
  1342.     INLINE $205F, $A041, $3E80;
  1343.     {$ENDC}
  1344. FUNCTION PBSetFLockAsync(paramBlock: ParmBlkPtr): OSErr;
  1345.     {$IFC NOT GENERATINGCFM}
  1346.     INLINE $205F, $A441, $3E80;
  1347.     {$ENDC}
  1348. FUNCTION PBRstFLockSync(paramBlock: ParmBlkPtr): OSErr;
  1349.     {$IFC NOT GENERATINGCFM}
  1350.     INLINE $205F, $A042, $3E80;
  1351.     {$ENDC}
  1352. FUNCTION PBRstFLockAsync(paramBlock: ParmBlkPtr): OSErr;
  1353.     {$IFC NOT GENERATINGCFM}
  1354.     INLINE $205F, $A442, $3E80;
  1355.     {$ENDC}
  1356. FUNCTION PBSetFVersSync(paramBlock: ParmBlkPtr): OSErr;
  1357.     {$IFC NOT GENERATINGCFM}
  1358.     INLINE $205F, $A043, $3E80;
  1359.     {$ENDC}
  1360. FUNCTION PBSetFVersAsync(paramBlock: ParmBlkPtr): OSErr;
  1361.     {$IFC NOT GENERATINGCFM}
  1362.     INLINE $205F, $A443, $3E80;
  1363.     {$ENDC}
  1364. FUNCTION PBAllocateSync(paramBlock: ParmBlkPtr): OSErr;
  1365.     {$IFC NOT GENERATINGCFM}
  1366.     INLINE $205F, $A010, $3E80;
  1367.     {$ENDC}
  1368. FUNCTION PBAllocateAsync(paramBlock: ParmBlkPtr): OSErr;
  1369.     {$IFC NOT GENERATINGCFM}
  1370.     INLINE $205F, $A410, $3E80;
  1371.     {$ENDC}
  1372. FUNCTION PBGetEOFSync(paramBlock: ParmBlkPtr): OSErr;
  1373.     {$IFC NOT GENERATINGCFM}
  1374.     INLINE $205F, $A011, $3E80;
  1375.     {$ENDC}
  1376. FUNCTION PBGetEOFAsync(paramBlock: ParmBlkPtr): OSErr;
  1377.     {$IFC NOT GENERATINGCFM}
  1378.     INLINE $205F, $A411, $3E80;
  1379.     {$ENDC}
  1380. FUNCTION PBSetEOFSync(paramBlock: ParmBlkPtr): OSErr;
  1381.     {$IFC NOT GENERATINGCFM}
  1382.     INLINE $205F, $A012, $3E80;
  1383.     {$ENDC}
  1384. FUNCTION PBSetEOFAsync(paramBlock: ParmBlkPtr): OSErr;
  1385.     {$IFC NOT GENERATINGCFM}
  1386.     INLINE $205F, $A412, $3E80;
  1387.     {$ENDC}
  1388. FUNCTION PBGetFPosSync(paramBlock: ParmBlkPtr): OSErr;
  1389.     {$IFC NOT GENERATINGCFM}
  1390.     INLINE $205F, $A018, $3E80;
  1391.     {$ENDC}
  1392. FUNCTION PBGetFPosAsync(paramBlock: ParmBlkPtr): OSErr;
  1393.     {$IFC NOT GENERATINGCFM}
  1394.     INLINE $205F, $A418, $3E80;
  1395.     {$ENDC}
  1396. FUNCTION PBSetFPosSync(paramBlock: ParmBlkPtr): OSErr;
  1397.     {$IFC NOT GENERATINGCFM}
  1398.     INLINE $205F, $A044, $3E80;
  1399.     {$ENDC}
  1400. FUNCTION PBSetFPosAsync(paramBlock: ParmBlkPtr): OSErr;
  1401.     {$IFC NOT GENERATINGCFM}
  1402.     INLINE $205F, $A444, $3E80;
  1403.     {$ENDC}
  1404. FUNCTION PBFlushFileSync(paramBlock: ParmBlkPtr): OSErr;
  1405.     {$IFC NOT GENERATINGCFM}
  1406.     INLINE $205F, $A045, $3E80;
  1407.     {$ENDC}
  1408. FUNCTION PBFlushFileAsync(paramBlock: ParmBlkPtr): OSErr;
  1409.     {$IFC NOT GENERATINGCFM}
  1410.     INLINE $205F, $A445, $3E80;
  1411.     {$ENDC}
  1412. FUNCTION PBMountVol(paramBlock: ParmBlkPtr): OSErr;
  1413.     {$IFC NOT GENERATINGCFM}
  1414.     INLINE $205F, $A00F, $3E80;
  1415.     {$ENDC}
  1416. FUNCTION PBUnmountVol(paramBlock: ParmBlkPtr): OSErr;
  1417.     {$IFC NOT GENERATINGCFM}
  1418.     INLINE $205F, $A00E, $3E80;
  1419.     {$ENDC}
  1420. {$IFC FOR_SYSTEM7_ONLY }
  1421. FUNCTION PBUnmountVolImmed(paramBlock: ParmBlkPtr): OSErr;
  1422.     {$IFC NOT GENERATINGCFM}
  1423.     INLINE $205F, $A20E, $3E80;
  1424.     {$ENDC}
  1425. {$ENDC}
  1426. FUNCTION PBEject(paramBlock: ParmBlkPtr): OSErr;
  1427.     {$IFC NOT GENERATINGCFM}
  1428.     INLINE $205F, $A017, $3E80;
  1429.     {$ENDC}
  1430. FUNCTION PBOffLine(paramBlock: ParmBlkPtr): OSErr;
  1431.     {$IFC NOT GENERATINGCFM}
  1432.     INLINE $205F, $A035, $3E80;
  1433.     {$ENDC}
  1434. FUNCTION PBCatSearchSync(paramBlock: CSParamPtr): OSErr;
  1435.     {$IFC NOT GENERATINGCFM}
  1436.     INLINE $205F, $7018, $A260, $3E80;
  1437.     {$ENDC}
  1438. FUNCTION PBCatSearchAsync(paramBlock: CSParamPtr): OSErr;
  1439.     {$IFC NOT GENERATINGCFM}
  1440.     INLINE $205F, $7018, $A660, $3E80;
  1441.     {$ENDC}
  1442. FUNCTION SetVol(volName: StringPtr; vRefNum: INTEGER): OSErr;
  1443. FUNCTION UnmountVol(volName: StringPtr; vRefNum: INTEGER): OSErr;
  1444. FUNCTION Eject(volName: StringPtr; vRefNum: INTEGER): OSErr;
  1445. FUNCTION FlushVol(volName: StringPtr; vRefNum: INTEGER): OSErr;
  1446. FUNCTION HSetVol(volName: StringPtr; vRefNum: INTEGER; dirID: LONGINT): OSErr;
  1447. {$IFC OLDROUTINELOCATIONS }
  1448. PROCEDURE AddDrive(drvrRefNum: INTEGER; drvNum: INTEGER; qEl: DrvQElPtr);
  1449. {$ENDC}
  1450. FUNCTION FSOpen(fileName: Str255; vRefNum: INTEGER; VAR refNum: INTEGER): OSErr;
  1451. FUNCTION OpenDF(fileName: Str255; vRefNum: INTEGER; VAR refNum: INTEGER): OSErr;
  1452. FUNCTION FSClose(refNum: INTEGER): OSErr;
  1453. FUNCTION FSRead(refNum: INTEGER; VAR count: LONGINT; buffPtr: UNIV Ptr): OSErr;
  1454. FUNCTION FSWrite(refNum: INTEGER; VAR count: LONGINT; buffPtr: UNIV Ptr): OSErr;
  1455. FUNCTION GetVInfo(drvNum: INTEGER; volName: StringPtr; VAR vRefNum: INTEGER; VAR freeBytes: LONGINT): OSErr;
  1456. FUNCTION GetFInfo(fileName: Str255; vRefNum: INTEGER; VAR fndrInfo: FInfo): OSErr;
  1457. FUNCTION GetVol(volName: StringPtr; VAR vRefNum: INTEGER): OSErr;
  1458. FUNCTION Create(fileName: Str255; vRefNum: INTEGER; creator: OSType; fileType: OSType): OSErr;
  1459. FUNCTION FSDelete(fileName: Str255; vRefNum: INTEGER): OSErr;
  1460. FUNCTION OpenRF(fileName: Str255; vRefNum: INTEGER; VAR refNum: INTEGER): OSErr;
  1461. FUNCTION Rename(oldName: Str255; vRefNum: INTEGER; newName: Str255): OSErr;
  1462. FUNCTION SetFInfo(fileName: Str255; vRefNum: INTEGER; {CONST}VAR fndrInfo: FInfo): OSErr;
  1463. FUNCTION SetFLock(fileName: Str255; vRefNum: INTEGER): OSErr;
  1464. FUNCTION RstFLock(fileName: Str255; vRefNum: INTEGER): OSErr;
  1465. FUNCTION Allocate(refNum: INTEGER; VAR count: LONGINT): OSErr;
  1466. FUNCTION GetEOF(refNum: INTEGER; VAR logEOF: LONGINT): OSErr;
  1467. FUNCTION SetEOF(refNum: INTEGER; logEOF: LONGINT): OSErr;
  1468. FUNCTION GetFPos(refNum: INTEGER; VAR filePos: LONGINT): OSErr;
  1469. FUNCTION SetFPos(refNum: INTEGER; posMode: INTEGER; posOff: LONGINT): OSErr;
  1470. FUNCTION GetVRefNum(fileRefNum: INTEGER; VAR vRefNum: INTEGER): OSErr;
  1471. FUNCTION PBOpenWDSync(paramBlock: WDPBPtr): OSErr;
  1472.     {$IFC NOT GENERATINGCFM}
  1473.     INLINE $205F, $7001, $A260, $3E80;
  1474.     {$ENDC}
  1475. FUNCTION PBOpenWDAsync(paramBlock: WDPBPtr): OSErr;
  1476.     {$IFC NOT GENERATINGCFM}
  1477.     INLINE $205F, $7001, $A660, $3E80;
  1478.     {$ENDC}
  1479. FUNCTION PBCloseWDSync(paramBlock: WDPBPtr): OSErr;
  1480.     {$IFC NOT GENERATINGCFM}
  1481.     INLINE $205F, $7002, $A260, $3E80;
  1482.     {$ENDC}
  1483. FUNCTION PBCloseWDAsync(paramBlock: WDPBPtr): OSErr;
  1484.     {$IFC NOT GENERATINGCFM}
  1485.     INLINE $205F, $7002, $A660, $3E80;
  1486.     {$ENDC}
  1487. FUNCTION PBHSetVolSync(paramBlock: WDPBPtr): OSErr;
  1488.     {$IFC NOT GENERATINGCFM}
  1489.     INLINE $205F, $A215, $3E80;
  1490.     {$ENDC}
  1491. FUNCTION PBHSetVolAsync(paramBlock: WDPBPtr): OSErr;
  1492.     {$IFC NOT GENERATINGCFM}
  1493.     INLINE $205F, $A615, $3E80;
  1494.     {$ENDC}
  1495. FUNCTION PBHGetVolSync(paramBlock: WDPBPtr): OSErr;
  1496.     {$IFC NOT GENERATINGCFM}
  1497.     INLINE $205F, $A214, $3E80;
  1498.     {$ENDC}
  1499. FUNCTION PBHGetVolAsync(paramBlock: WDPBPtr): OSErr;
  1500.     {$IFC NOT GENERATINGCFM}
  1501.     INLINE $205F, $A614, $3E80;
  1502.     {$ENDC}
  1503. FUNCTION PBCatMoveSync(paramBlock: CMovePBPtr): OSErr;
  1504.     {$IFC NOT GENERATINGCFM}
  1505.     INLINE $205F, $7005, $A260, $3E80;
  1506.     {$ENDC}
  1507. FUNCTION PBCatMoveAsync(paramBlock: CMovePBPtr): OSErr;
  1508.     {$IFC NOT GENERATINGCFM}
  1509.     INLINE $205F, $7005, $A660, $3E80;
  1510.     {$ENDC}
  1511. FUNCTION PBDirCreateSync(paramBlock: HParmBlkPtr): OSErr;
  1512.     {$IFC NOT GENERATINGCFM}
  1513.     INLINE $205F, $7006, $A260, $3E80;
  1514.     {$ENDC}
  1515. FUNCTION PBDirCreateAsync(paramBlock: HParmBlkPtr): OSErr;
  1516.     {$IFC NOT GENERATINGCFM}
  1517.     INLINE $205F, $7006, $A660, $3E80;
  1518.     {$ENDC}
  1519. FUNCTION PBGetWDInfoSync(paramBlock: WDPBPtr): OSErr;
  1520.     {$IFC NOT GENERATINGCFM}
  1521.     INLINE $205F, $7007, $A260, $3E80;
  1522.     {$ENDC}
  1523. FUNCTION PBGetWDInfoAsync(paramBlock: WDPBPtr): OSErr;
  1524.     {$IFC NOT GENERATINGCFM}
  1525.     INLINE $205F, $7007, $A660, $3E80;
  1526.     {$ENDC}
  1527. FUNCTION PBGetFCBInfoSync(paramBlock: FCBPBPtr): OSErr;
  1528.     {$IFC NOT GENERATINGCFM}
  1529.     INLINE $205F, $7008, $A260, $3E80;
  1530.     {$ENDC}
  1531. FUNCTION PBGetFCBInfoAsync(paramBlock: FCBPBPtr): OSErr;
  1532.     {$IFC NOT GENERATINGCFM}
  1533.     INLINE $205F, $7008, $A660, $3E80;
  1534.     {$ENDC}
  1535. FUNCTION PBGetCatInfoSync(paramBlock: CInfoPBPtr): OSErr;
  1536.     {$IFC NOT GENERATINGCFM}
  1537.     INLINE $205F, $7009, $A260, $3E80;
  1538.     {$ENDC}
  1539. FUNCTION PBGetCatInfoAsync(paramBlock: CInfoPBPtr): OSErr;
  1540.     {$IFC NOT GENERATINGCFM}
  1541.     INLINE $205F, $7009, $A660, $3E80;
  1542.     {$ENDC}
  1543. FUNCTION PBSetCatInfoSync(paramBlock: CInfoPBPtr): OSErr;
  1544.     {$IFC NOT GENERATINGCFM}
  1545.     INLINE $205F, $700A, $A260, $3E80;
  1546.     {$ENDC}
  1547. FUNCTION PBSetCatInfoAsync(paramBlock: CInfoPBPtr): OSErr;
  1548.     {$IFC NOT GENERATINGCFM}
  1549.     INLINE $205F, $700A, $A660, $3E80;
  1550.     {$ENDC}
  1551. FUNCTION PBAllocContigSync(paramBlock: ParmBlkPtr): OSErr;
  1552.     {$IFC NOT GENERATINGCFM}
  1553.     INLINE $205F, $A210, $3E80;
  1554.     {$ENDC}
  1555. FUNCTION PBAllocContigAsync(paramBlock: ParmBlkPtr): OSErr;
  1556.     {$IFC NOT GENERATINGCFM}
  1557.     INLINE $205F, $A610, $3E80;
  1558.     {$ENDC}
  1559. FUNCTION PBLockRangeSync(paramBlock: ParmBlkPtr): OSErr;
  1560.     {$IFC NOT GENERATINGCFM}
  1561.     INLINE $205F, $7010, $A260, $3E80;
  1562.     {$ENDC}
  1563. FUNCTION PBLockRangeAsync(paramBlock: ParmBlkPtr): OSErr;
  1564.     {$IFC NOT GENERATINGCFM}
  1565.     INLINE $205F, $7010, $A660, $3E80;
  1566.     {$ENDC}
  1567. FUNCTION PBUnlockRangeSync(paramBlock: ParmBlkPtr): OSErr;
  1568.     {$IFC NOT GENERATINGCFM}
  1569.     INLINE $205F, $7011, $A260, $3E80;
  1570.     {$ENDC}
  1571. FUNCTION PBUnlockRangeAsync(paramBlock: ParmBlkPtr): OSErr;
  1572.     {$IFC NOT GENERATINGCFM}
  1573.     INLINE $205F, $7011, $A660, $3E80;
  1574.     {$ENDC}
  1575. FUNCTION PBSetVInfoSync(paramBlock: HParmBlkPtr): OSErr;
  1576.     {$IFC NOT GENERATINGCFM}
  1577.     INLINE $205F, $700B, $A260, $3E80;
  1578.     {$ENDC}
  1579. FUNCTION PBSetVInfoAsync(paramBlock: HParmBlkPtr): OSErr;
  1580.     {$IFC NOT GENERATINGCFM}
  1581.     INLINE $205F, $700B, $A660, $3E80;
  1582.     {$ENDC}
  1583. FUNCTION PBHGetVInfoSync(paramBlock: HParmBlkPtr): OSErr;
  1584.     {$IFC NOT GENERATINGCFM}
  1585.     INLINE $205F, $A207, $3E80;
  1586.     {$ENDC}
  1587. FUNCTION PBHGetVInfoAsync(paramBlock: HParmBlkPtr): OSErr;
  1588.     {$IFC NOT GENERATINGCFM}
  1589.     INLINE $205F, $A607, $3E80;
  1590.     {$ENDC}
  1591. FUNCTION PBHOpenSync(paramBlock: HParmBlkPtr): OSErr;
  1592.     {$IFC NOT GENERATINGCFM}
  1593.     INLINE $205F, $A200, $3E80;
  1594.     {$ENDC}
  1595. FUNCTION PBHOpenAsync(paramBlock: HParmBlkPtr): OSErr;
  1596.     {$IFC NOT GENERATINGCFM}
  1597.     INLINE $205F, $A600, $3E80;
  1598.     {$ENDC}
  1599. FUNCTION PBHOpenRFSync(paramBlock: HParmBlkPtr): OSErr;
  1600.     {$IFC NOT GENERATINGCFM}
  1601.     INLINE $205F, $A20A, $3E80;
  1602.     {$ENDC}
  1603. FUNCTION PBHOpenRFAsync(paramBlock: HParmBlkPtr): OSErr;
  1604.     {$IFC NOT GENERATINGCFM}
  1605.     INLINE $205F, $A60A, $3E80;
  1606.     {$ENDC}
  1607. FUNCTION PBHOpenDFSync(paramBlock: HParmBlkPtr): OSErr;
  1608.     {$IFC NOT GENERATINGCFM}
  1609.     INLINE $205F, $701A, $A260, $3E80;
  1610.     {$ENDC}
  1611. FUNCTION PBHOpenDFAsync(paramBlock: HParmBlkPtr): OSErr;
  1612.     {$IFC NOT GENERATINGCFM}
  1613.     INLINE $205F, $701A, $A660, $3E80;
  1614.     {$ENDC}
  1615. FUNCTION PBHCreateSync(paramBlock: HParmBlkPtr): OSErr;
  1616.     {$IFC NOT GENERATINGCFM}
  1617.     INLINE $205F, $A208, $3E80;
  1618.     {$ENDC}
  1619. FUNCTION PBHCreateAsync(paramBlock: HParmBlkPtr): OSErr;
  1620.     {$IFC NOT GENERATINGCFM}
  1621.     INLINE $205F, $A608, $3E80;
  1622.     {$ENDC}
  1623. FUNCTION PBHDeleteSync(paramBlock: HParmBlkPtr): OSErr;
  1624.     {$IFC NOT GENERATINGCFM}
  1625.     INLINE $205F, $A209, $3E80;
  1626.     {$ENDC}
  1627. FUNCTION PBHDeleteAsync(paramBlock: HParmBlkPtr): OSErr;
  1628.     {$IFC NOT GENERATINGCFM}
  1629.     INLINE $205F, $A609, $3E80;
  1630.     {$ENDC}
  1631. FUNCTION PBHRenameSync(paramBlock: HParmBlkPtr): OSErr;
  1632.     {$IFC NOT GENERATINGCFM}
  1633.     INLINE $205F, $A20B, $3E80;
  1634.     {$ENDC}
  1635. FUNCTION PBHRenameAsync(paramBlock: HParmBlkPtr): OSErr;
  1636.     {$IFC NOT GENERATINGCFM}
  1637.     INLINE $205F, $A60B, $3E80;
  1638.     {$ENDC}
  1639. FUNCTION PBHRstFLockSync(paramBlock: HParmBlkPtr): OSErr;
  1640.     {$IFC NOT GENERATINGCFM}
  1641.     INLINE $205F, $A242, $3E80;
  1642.     {$ENDC}
  1643. FUNCTION PBHRstFLockAsync(paramBlock: HParmBlkPtr): OSErr;
  1644.     {$IFC NOT GENERATINGCFM}
  1645.     INLINE $205F, $A642, $3E80;
  1646.     {$ENDC}
  1647. FUNCTION PBHSetFLockSync(paramBlock: HParmBlkPtr): OSErr;
  1648.     {$IFC NOT GENERATINGCFM}
  1649.     INLINE $205F, $A241, $3E80;
  1650.     {$ENDC}
  1651. FUNCTION PBHSetFLockAsync(paramBlock: HParmBlkPtr): OSErr;
  1652.     {$IFC NOT GENERATINGCFM}
  1653.     INLINE $205F, $A641, $3E80;
  1654.     {$ENDC}
  1655. FUNCTION PBHGetFInfoSync(paramBlock: HParmBlkPtr): OSErr;
  1656.     {$IFC NOT GENERATINGCFM}
  1657.     INLINE $205F, $A20C, $3E80;
  1658.     {$ENDC}
  1659. FUNCTION PBHGetFInfoAsync(paramBlock: HParmBlkPtr): OSErr;
  1660.     {$IFC NOT GENERATINGCFM}
  1661.     INLINE $205F, $A60C, $3E80;
  1662.     {$ENDC}
  1663. FUNCTION PBHSetFInfoSync(paramBlock: HParmBlkPtr): OSErr;
  1664.     {$IFC NOT GENERATINGCFM}
  1665.     INLINE $205F, $A20D, $3E80;
  1666.     {$ENDC}
  1667. FUNCTION PBHSetFInfoAsync(paramBlock: HParmBlkPtr): OSErr;
  1668.     {$IFC NOT GENERATINGCFM}
  1669.     INLINE $205F, $A60D, $3E80;
  1670.     {$ENDC}
  1671. FUNCTION PBMakeFSSpecSync(paramBlock: HParmBlkPtr): OSErr;
  1672.     {$IFC NOT GENERATINGCFM}
  1673.     INLINE $205F, $701B, $A260, $3E80;
  1674.     {$ENDC}
  1675. FUNCTION PBMakeFSSpecAsync(paramBlock: HParmBlkPtr): OSErr;
  1676.     {$IFC NOT GENERATINGCFM}
  1677.     INLINE $205F, $701B, $A660, $3E80;
  1678.     {$ENDC}
  1679. PROCEDURE FInitQueue;
  1680.     {$IFC NOT GENERATINGCFM}
  1681.     INLINE $A016;
  1682.     {$ENDC}
  1683. FUNCTION GetFSQHdr: QHdrPtr;
  1684.     {$IFC NOT GENERATINGCFM}
  1685.     INLINE $2EBC, $0000, $0360;
  1686.     {$ENDC}
  1687. FUNCTION GetVCBQHdr: QHdrPtr;
  1688.     {$IFC NOT GENERATINGCFM}
  1689.     INLINE $2EBC, $0000, $0356;
  1690.     {$ENDC}
  1691. {$IFC OLDROUTINELOCATIONS }
  1692. FUNCTION GetDrvQHdr: QHdrPtr;
  1693.     {$IFC NOT GENERATINGCFM}
  1694.     INLINE $2EBC, $0000, $0308;
  1695.     {$ENDC}
  1696. {$ENDC}
  1697. FUNCTION HGetVol(volName: StringPtr; VAR vRefNum: INTEGER; VAR dirID: LONGINT): OSErr;
  1698. FUNCTION HOpen(vRefNum: INTEGER; dirID: LONGINT; fileName: Str255; permission: SInt8; VAR refNum: INTEGER): OSErr;
  1699. FUNCTION HOpenDF(vRefNum: INTEGER; dirID: LONGINT; fileName: Str255; permission: SInt8; VAR refNum: INTEGER): OSErr;
  1700. FUNCTION HOpenRF(vRefNum: INTEGER; dirID: LONGINT; fileName: Str255; permission: SInt8; VAR refNum: INTEGER): OSErr;
  1701. FUNCTION AllocContig(refNum: INTEGER; VAR count: LONGINT): OSErr;
  1702. FUNCTION HCreate(vRefNum: INTEGER; dirID: LONGINT; fileName: Str255; creator: OSType; fileType: OSType): OSErr;
  1703. FUNCTION DirCreate(vRefNum: INTEGER; parentDirID: LONGINT; directoryName: Str255; VAR createdDirID: LONGINT): OSErr;
  1704. FUNCTION HDelete(vRefNum: INTEGER; dirID: LONGINT; fileName: Str255): OSErr;
  1705. FUNCTION HGetFInfo(vRefNum: INTEGER; dirID: LONGINT; fileName: Str255; VAR fndrInfo: FInfo): OSErr;
  1706. FUNCTION HSetFInfo(vRefNum: INTEGER; dirID: LONGINT; fileName: Str255; {CONST}VAR fndrInfo: FInfo): OSErr;
  1707. FUNCTION HSetFLock(vRefNum: INTEGER; dirID: LONGINT; fileName: Str255): OSErr;
  1708. FUNCTION HRstFLock(vRefNum: INTEGER; dirID: LONGINT; fileName: Str255): OSErr;
  1709. FUNCTION HRename(vRefNum: INTEGER; dirID: LONGINT; oldName: Str255; newName: Str255): OSErr;
  1710. FUNCTION CatMove(vRefNum: INTEGER; dirID: LONGINT; oldName: Str255; newDirID: LONGINT; newName: Str255): OSErr;
  1711. FUNCTION OpenWD(vRefNum: INTEGER; dirID: LONGINT; procID: LONGINT; VAR wdRefNum: INTEGER): OSErr;
  1712. FUNCTION CloseWD(wdRefNum: INTEGER): OSErr;
  1713. FUNCTION GetWDInfo(wdRefNum: INTEGER; VAR vRefNum: INTEGER; VAR dirID: LONGINT; VAR procID: LONGINT): OSErr;
  1714. {   shared environment   }
  1715. FUNCTION PBHGetVolParmsSync(paramBlock: HParmBlkPtr): OSErr;
  1716.     {$IFC NOT GENERATINGCFM}
  1717.     INLINE $205F, $7030, $A260, $3E80;
  1718.     {$ENDC}
  1719. FUNCTION PBHGetVolParmsAsync(paramBlock: HParmBlkPtr): OSErr;
  1720.     {$IFC NOT GENERATINGCFM}
  1721.     INLINE $205F, $7030, $A660, $3E80;
  1722.     {$ENDC}
  1723. FUNCTION PBHGetLogInInfoSync(paramBlock: HParmBlkPtr): OSErr;
  1724.     {$IFC NOT GENERATINGCFM}
  1725.     INLINE $205F, $7031, $A260, $3E80;
  1726.     {$ENDC}
  1727. FUNCTION PBHGetLogInInfoAsync(paramBlock: HParmBlkPtr): OSErr;
  1728.     {$IFC NOT GENERATINGCFM}
  1729.     INLINE $205F, $7031, $A660, $3E80;
  1730.     {$ENDC}
  1731. FUNCTION PBHGetDirAccessSync(paramBlock: HParmBlkPtr): OSErr;
  1732.     {$IFC NOT GENERATINGCFM}
  1733.     INLINE $205F, $7032, $A260, $3E80;
  1734.     {$ENDC}
  1735. FUNCTION PBHGetDirAccessAsync(paramBlock: HParmBlkPtr): OSErr;
  1736.     {$IFC NOT GENERATINGCFM}
  1737.     INLINE $205F, $7032, $A660, $3E80;
  1738.     {$ENDC}
  1739. FUNCTION PBHSetDirAccessSync(paramBlock: HParmBlkPtr): OSErr;
  1740.     {$IFC NOT GENERATINGCFM}
  1741.     INLINE $205F, $7033, $A260, $3E80;
  1742.     {$ENDC}
  1743. FUNCTION PBHSetDirAccessAsync(paramBlock: HParmBlkPtr): OSErr;
  1744.     {$IFC NOT GENERATINGCFM}
  1745.     INLINE $205F, $7033, $A660, $3E80;
  1746.     {$ENDC}
  1747. FUNCTION PBHMapIDSync(paramBlock: HParmBlkPtr): OSErr;
  1748.     {$IFC NOT GENERATINGCFM}
  1749.     INLINE $205F, $7034, $A260, $3E80;
  1750.     {$ENDC}
  1751. FUNCTION PBHMapIDAsync(paramBlock: HParmBlkPtr): OSErr;
  1752.     {$IFC NOT GENERATINGCFM}
  1753.     INLINE $205F, $7034, $A660, $3E80;
  1754.     {$ENDC}
  1755. FUNCTION PBHMapNameSync(paramBlock: HParmBlkPtr): OSErr;
  1756.     {$IFC NOT GENERATINGCFM}
  1757.     INLINE $205F, $7035, $A260, $3E80;
  1758.     {$ENDC}
  1759. FUNCTION PBHMapNameAsync(paramBlock: HParmBlkPtr): OSErr;
  1760.     {$IFC NOT GENERATINGCFM}
  1761.     INLINE $205F, $7035, $A660, $3E80;
  1762.     {$ENDC}
  1763. FUNCTION PBHCopyFileSync(paramBlock: HParmBlkPtr): OSErr;
  1764.     {$IFC NOT GENERATINGCFM}
  1765.     INLINE $205F, $7036, $A260, $3E80;
  1766.     {$ENDC}
  1767. FUNCTION PBHCopyFileAsync(paramBlock: HParmBlkPtr): OSErr;
  1768.     {$IFC NOT GENERATINGCFM}
  1769.     INLINE $205F, $7036, $A660, $3E80;
  1770.     {$ENDC}
  1771. FUNCTION PBHMoveRenameSync(paramBlock: HParmBlkPtr): OSErr;
  1772.     {$IFC NOT GENERATINGCFM}
  1773.     INLINE $205F, $7037, $A260, $3E80;
  1774.     {$ENDC}
  1775. FUNCTION PBHMoveRenameAsync(paramBlock: HParmBlkPtr): OSErr;
  1776.     {$IFC NOT GENERATINGCFM}
  1777.     INLINE $205F, $7037, $A660, $3E80;
  1778.     {$ENDC}
  1779. FUNCTION PBHOpenDenySync(paramBlock: HParmBlkPtr): OSErr;
  1780.     {$IFC NOT GENERATINGCFM}
  1781.     INLINE $205F, $7038, $A260, $3E80;
  1782.     {$ENDC}
  1783. FUNCTION PBHOpenDenyAsync(paramBlock: HParmBlkPtr): OSErr;
  1784.     {$IFC NOT GENERATINGCFM}
  1785.     INLINE $205F, $7038, $A660, $3E80;
  1786.     {$ENDC}
  1787. FUNCTION PBHOpenRFDenySync(paramBlock: HParmBlkPtr): OSErr;
  1788.     {$IFC NOT GENERATINGCFM}
  1789.     INLINE $205F, $7039, $A260, $3E80;
  1790.     {$ENDC}
  1791. FUNCTION PBHOpenRFDenyAsync(paramBlock: HParmBlkPtr): OSErr;
  1792.     {$IFC NOT GENERATINGCFM}
  1793.     INLINE $205F, $7039, $A660, $3E80;
  1794.     {$ENDC}
  1795. FUNCTION PBExchangeFilesSync(paramBlock: HParmBlkPtr): OSErr;
  1796.     {$IFC NOT GENERATINGCFM}
  1797.     INLINE $205F, $7017, $A260, $3E80;
  1798.     {$ENDC}
  1799. FUNCTION PBExchangeFilesAsync(paramBlock: HParmBlkPtr): OSErr;
  1800.     {$IFC NOT GENERATINGCFM}
  1801.     INLINE $205F, $7017, $A660, $3E80;
  1802.     {$ENDC}
  1803. FUNCTION PBCreateFileIDRefSync(paramBlock: HParmBlkPtr): OSErr;
  1804.     {$IFC NOT GENERATINGCFM}
  1805.     INLINE $205F, $7014, $A260, $3E80;
  1806.     {$ENDC}
  1807. FUNCTION PBCreateFileIDRefAsync(paramBlock: HParmBlkPtr): OSErr;
  1808.     {$IFC NOT GENERATINGCFM}
  1809.     INLINE $205F, $7014, $A660, $3E80;
  1810.     {$ENDC}
  1811. FUNCTION PBResolveFileIDRefSync(paramBlock: HParmBlkPtr): OSErr;
  1812.     {$IFC NOT GENERATINGCFM}
  1813.     INLINE $205F, $7016, $A260, $3E80;
  1814.     {$ENDC}
  1815. FUNCTION PBResolveFileIDRefAsync(paramBlock: HParmBlkPtr): OSErr;
  1816.     {$IFC NOT GENERATINGCFM}
  1817.     INLINE $205F, $7016, $A660, $3E80;
  1818.     {$ENDC}
  1819. FUNCTION PBDeleteFileIDRefSync(paramBlock: HParmBlkPtr): OSErr;
  1820.     {$IFC NOT GENERATINGCFM}
  1821.     INLINE $205F, $7015, $A260, $3E80;
  1822.     {$ENDC}
  1823. FUNCTION PBDeleteFileIDRefAsync(paramBlock: HParmBlkPtr): OSErr;
  1824.     {$IFC NOT GENERATINGCFM}
  1825.     INLINE $205F, $7015, $A660, $3E80;
  1826.     {$ENDC}
  1827. FUNCTION PBGetForeignPrivsSync(paramBlock: HParmBlkPtr): OSErr;
  1828.     {$IFC NOT GENERATINGCFM}
  1829.     INLINE $205F, $7060, $A260, $3E80;
  1830.     {$ENDC}
  1831. FUNCTION PBGetForeignPrivsAsync(paramBlock: HParmBlkPtr): OSErr;
  1832.     {$IFC NOT GENERATINGCFM}
  1833.     INLINE $205F, $7060, $A660, $3E80;
  1834.     {$ENDC}
  1835. FUNCTION PBSetForeignPrivsSync(paramBlock: HParmBlkPtr): OSErr;
  1836.     {$IFC NOT GENERATINGCFM}
  1837.     INLINE $205F, $7061, $A260, $3E80;
  1838.     {$ENDC}
  1839. FUNCTION PBSetForeignPrivsAsync(paramBlock: HParmBlkPtr): OSErr;
  1840.     {$IFC NOT GENERATINGCFM}
  1841.     INLINE $205F, $7061, $A660, $3E80;
  1842.     {$ENDC}
  1843. {   Desktop Manager   }
  1844. FUNCTION PBDTGetPath(paramBlock: DTPBPtr): OSErr;
  1845.     {$IFC NOT GENERATINGCFM}
  1846.     INLINE $205F, $7020, $A260, $3E80;
  1847.     {$ENDC}
  1848. FUNCTION PBDTCloseDown(paramBlock: DTPBPtr): OSErr;
  1849.     {$IFC NOT GENERATINGCFM}
  1850.     INLINE $205F, $7021, $A260, $3E80;
  1851.     {$ENDC}
  1852. FUNCTION PBDTAddIconSync(paramBlock: DTPBPtr): OSErr;
  1853.     {$IFC NOT GENERATINGCFM}
  1854.     INLINE $205F, $7022, $A260, $3E80;
  1855.     {$ENDC}
  1856. FUNCTION PBDTAddIconAsync(paramBlock: DTPBPtr): OSErr;
  1857.     {$IFC NOT GENERATINGCFM}
  1858.     INLINE $205F, $7022, $A660, $3E80;
  1859.     {$ENDC}
  1860. FUNCTION PBDTGetIconSync(paramBlock: DTPBPtr): OSErr;
  1861.     {$IFC NOT GENERATINGCFM}
  1862.     INLINE $205F, $7023, $A260, $3E80;
  1863.     {$ENDC}
  1864. FUNCTION PBDTGetIconAsync(paramBlock: DTPBPtr): OSErr;
  1865.     {$IFC NOT GENERATINGCFM}
  1866.     INLINE $205F, $7023, $A660, $3E80;
  1867.     {$ENDC}
  1868. FUNCTION PBDTGetIconInfoSync(paramBlock: DTPBPtr): OSErr;
  1869.     {$IFC NOT GENERATINGCFM}
  1870.     INLINE $205F, $7024, $A260, $3E80;
  1871.     {$ENDC}
  1872. FUNCTION PBDTGetIconInfoAsync(paramBlock: DTPBPtr): OSErr;
  1873.     {$IFC NOT GENERATINGCFM}
  1874.     INLINE $205F, $7024, $A660, $3E80;
  1875.     {$ENDC}
  1876. FUNCTION PBDTAddAPPLSync(paramBlock: DTPBPtr): OSErr;
  1877.     {$IFC NOT GENERATINGCFM}
  1878.     INLINE $205F, $7025, $A260, $3E80;
  1879.     {$ENDC}
  1880. FUNCTION PBDTAddAPPLAsync(paramBlock: DTPBPtr): OSErr;
  1881.     {$IFC NOT GENERATINGCFM}
  1882.     INLINE $205F, $7025, $A660, $3E80;
  1883.     {$ENDC}
  1884. FUNCTION PBDTRemoveAPPLSync(paramBlock: DTPBPtr): OSErr;
  1885.     {$IFC NOT GENERATINGCFM}
  1886.     INLINE $205F, $7026, $A260, $3E80;
  1887.     {$ENDC}
  1888. FUNCTION PBDTRemoveAPPLAsync(paramBlock: DTPBPtr): OSErr;
  1889.     {$IFC NOT GENERATINGCFM}
  1890.     INLINE $205F, $7026, $A660, $3E80;
  1891.     {$ENDC}
  1892. FUNCTION PBDTGetAPPLSync(paramBlock: DTPBPtr): OSErr;
  1893.     {$IFC NOT GENERATINGCFM}
  1894.     INLINE $205F, $7027, $A260, $3E80;
  1895.     {$ENDC}
  1896. FUNCTION PBDTGetAPPLAsync(paramBlock: DTPBPtr): OSErr;
  1897.     {$IFC NOT GENERATINGCFM}
  1898.     INLINE $205F, $7027, $A660, $3E80;
  1899.     {$ENDC}
  1900. FUNCTION PBDTSetCommentSync(paramBlock: DTPBPtr): OSErr;
  1901.     {$IFC NOT GENERATINGCFM}
  1902.     INLINE $205F, $7028, $A260, $3E80;
  1903.     {$ENDC}
  1904. FUNCTION PBDTSetCommentAsync(paramBlock: DTPBPtr): OSErr;
  1905.     {$IFC NOT GENERATINGCFM}
  1906.     INLINE $205F, $7028, $A660, $3E80;
  1907.     {$ENDC}
  1908. FUNCTION PBDTRemoveCommentSync(paramBlock: DTPBPtr): OSErr;
  1909.     {$IFC NOT GENERATINGCFM}
  1910.     INLINE $205F, $7029, $A260, $3E80;
  1911.     {$ENDC}
  1912. FUNCTION PBDTRemoveCommentAsync(paramBlock: DTPBPtr): OSErr;
  1913.     {$IFC NOT GENERATINGCFM}
  1914.     INLINE $205F, $7029, $A660, $3E80;
  1915.     {$ENDC}
  1916. FUNCTION PBDTGetCommentSync(paramBlock: DTPBPtr): OSErr;
  1917.     {$IFC NOT GENERATINGCFM}
  1918.     INLINE $205F, $702A, $A260, $3E80;
  1919.     {$ENDC}
  1920. FUNCTION PBDTGetCommentAsync(paramBlock: DTPBPtr): OSErr;
  1921.     {$IFC NOT GENERATINGCFM}
  1922.     INLINE $205F, $702A, $A660, $3E80;
  1923.     {$ENDC}
  1924. FUNCTION PBDTFlushSync(paramBlock: DTPBPtr): OSErr;
  1925.     {$IFC NOT GENERATINGCFM}
  1926.     INLINE $205F, $702B, $A260, $3E80;
  1927.     {$ENDC}
  1928. FUNCTION PBDTFlushAsync(paramBlock: DTPBPtr): OSErr;
  1929.     {$IFC NOT GENERATINGCFM}
  1930.     INLINE $205F, $702B, $A660, $3E80;
  1931.     {$ENDC}
  1932. FUNCTION PBDTResetSync(paramBlock: DTPBPtr): OSErr;
  1933.     {$IFC NOT GENERATINGCFM}
  1934.     INLINE $205F, $702C, $A260, $3E80;
  1935.     {$ENDC}
  1936. FUNCTION PBDTResetAsync(paramBlock: DTPBPtr): OSErr;
  1937.     {$IFC NOT GENERATINGCFM}
  1938.     INLINE $205F, $702C, $A660, $3E80;
  1939.     {$ENDC}
  1940. FUNCTION PBDTGetInfoSync(paramBlock: DTPBPtr): OSErr;
  1941.     {$IFC NOT GENERATINGCFM}
  1942.     INLINE $205F, $702D, $A260, $3E80;
  1943.     {$ENDC}
  1944. FUNCTION PBDTGetInfoAsync(paramBlock: DTPBPtr): OSErr;
  1945.     {$IFC NOT GENERATINGCFM}
  1946.     INLINE $205F, $702D, $A660, $3E80;
  1947.     {$ENDC}
  1948. FUNCTION PBDTOpenInform(paramBlock: DTPBPtr): OSErr;
  1949.     {$IFC NOT GENERATINGCFM}
  1950.     INLINE $205F, $702E, $A060, $3E80;
  1951.     {$ENDC}
  1952. FUNCTION PBDTDeleteSync(paramBlock: DTPBPtr): OSErr;
  1953.     {$IFC NOT GENERATINGCFM}
  1954.     INLINE $205F, $702F, $A060, $3E80;
  1955.     {$ENDC}
  1956. FUNCTION PBDTDeleteAsync(paramBlock: DTPBPtr): OSErr;
  1957.     {$IFC NOT GENERATINGCFM}
  1958.     INLINE $205F, $702F, $A460, $3E80;
  1959.     {$ENDC}
  1960. {   VolumeMount traps   }
  1961. FUNCTION PBGetVolMountInfoSize(paramBlock: ParmBlkPtr): OSErr;
  1962.     {$IFC NOT GENERATINGCFM}
  1963.     INLINE $205F, $703F, $A260, $3E80;
  1964.     {$ENDC}
  1965. FUNCTION PBGetVolMountInfo(paramBlock: ParmBlkPtr): OSErr;
  1966.     {$IFC NOT GENERATINGCFM}
  1967.     INLINE $205F, $7040, $A260, $3E80;
  1968.     {$ENDC}
  1969. FUNCTION PBVolumeMount(paramBlock: ParmBlkPtr): OSErr;
  1970.     {$IFC NOT GENERATINGCFM}
  1971.     INLINE $205F, $7041, $A260, $3E80;
  1972.     {$ENDC}
  1973. {   FSp traps   }
  1974. FUNCTION FSMakeFSSpec(vRefNum: INTEGER; dirID: LONGINT; fileName: Str255; VAR spec: FSSpec): OSErr;
  1975.     {$IFC NOT GENERATINGCFM}
  1976.     INLINE $7001, $AA52;
  1977.     {$ENDC}
  1978. FUNCTION FSpOpenDF({CONST}VAR spec: FSSpec; permission: SInt8; VAR refNum: INTEGER): OSErr;
  1979.     {$IFC NOT GENERATINGCFM}
  1980.     INLINE $7002, $AA52;
  1981.     {$ENDC}
  1982. FUNCTION FSpOpenRF({CONST}VAR spec: FSSpec; permission: SInt8; VAR refNum: INTEGER): OSErr;
  1983.     {$IFC NOT GENERATINGCFM}
  1984.     INLINE $7003, $AA52;
  1985.     {$ENDC}
  1986. FUNCTION FSpCreate({CONST}VAR spec: FSSpec; creator: OSType; fileType: OSType; scriptTag: ScriptCode): OSErr;
  1987.     {$IFC NOT GENERATINGCFM}
  1988.     INLINE $7004, $AA52;
  1989.     {$ENDC}
  1990. FUNCTION FSpDirCreate({CONST}VAR spec: FSSpec; scriptTag: ScriptCode; VAR createdDirID: LONGINT): OSErr;
  1991.     {$IFC NOT GENERATINGCFM}
  1992.     INLINE $7005, $AA52;
  1993.     {$ENDC}
  1994. FUNCTION FSpDelete({CONST}VAR spec: FSSpec): OSErr;
  1995.     {$IFC NOT GENERATINGCFM}
  1996.     INLINE $7006, $AA52;
  1997.     {$ENDC}
  1998. FUNCTION FSpGetFInfo({CONST}VAR spec: FSSpec; VAR fndrInfo: FInfo): OSErr;
  1999.     {$IFC NOT GENERATINGCFM}
  2000.     INLINE $7007, $AA52;
  2001.     {$ENDC}
  2002. FUNCTION FSpSetFInfo({CONST}VAR spec: FSSpec; {CONST}VAR fndrInfo: FInfo): OSErr;
  2003.     {$IFC NOT GENERATINGCFM}
  2004.     INLINE $7008, $AA52;
  2005.     {$ENDC}
  2006. FUNCTION FSpSetFLock({CONST}VAR spec: FSSpec): OSErr;
  2007.     {$IFC NOT GENERATINGCFM}
  2008.     INLINE $7009, $AA52;
  2009.     {$ENDC}
  2010. FUNCTION FSpRstFLock({CONST}VAR spec: FSSpec): OSErr;
  2011.     {$IFC NOT GENERATINGCFM}
  2012.     INLINE $700A, $AA52;
  2013.     {$ENDC}
  2014. FUNCTION FSpRename({CONST}VAR spec: FSSpec; newName: Str255): OSErr;
  2015.     {$IFC NOT GENERATINGCFM}
  2016.     INLINE $700B, $AA52;
  2017.     {$ENDC}
  2018. FUNCTION FSpCatMove({CONST}VAR source: FSSpec; {CONST}VAR dest: FSSpec): OSErr;
  2019.     {$IFC NOT GENERATINGCFM}
  2020.     INLINE $700C, $AA52;
  2021.     {$ENDC}
  2022. FUNCTION FSpExchangeFiles({CONST}VAR source: FSSpec; {CONST}VAR dest: FSSpec): OSErr;
  2023.     {$IFC NOT GENERATINGCFM}
  2024.     INLINE $700F, $AA52;
  2025.     {$ENDC}
  2026. FUNCTION PBShareSync(paramBlock: HParmBlkPtr): OSErr;
  2027.     {$IFC NOT GENERATINGCFM}
  2028.     INLINE $205F, $7042, $A260, $3E80;
  2029.     {$ENDC}
  2030. FUNCTION PBShareAsync(paramBlock: HParmBlkPtr): OSErr;
  2031.     {$IFC NOT GENERATINGCFM}
  2032.     INLINE $205F, $7042, $A660, $3E80;
  2033.     {$ENDC}
  2034. FUNCTION PBUnshareSync(paramBlock: HParmBlkPtr): OSErr;
  2035.     {$IFC NOT GENERATINGCFM}
  2036.     INLINE $205F, $7043, $A260, $3E80;
  2037.     {$ENDC}
  2038. FUNCTION PBUnshareAsync(paramBlock: HParmBlkPtr): OSErr;
  2039.     {$IFC NOT GENERATINGCFM}
  2040.     INLINE $205F, $7043, $A660, $3E80;
  2041.     {$ENDC}
  2042. FUNCTION PBGetUGEntrySync(paramBlock: HParmBlkPtr): OSErr;
  2043.     {$IFC NOT GENERATINGCFM}
  2044.     INLINE $205F, $7044, $A260, $3E80;
  2045.     {$ENDC}
  2046. FUNCTION PBGetUGEntryAsync(paramBlock: HParmBlkPtr): OSErr;
  2047.     {$IFC NOT GENERATINGCFM}
  2048.     INLINE $205F, $7044, $A660, $3E80;
  2049.     {$ENDC}
  2050. {$IFC OLDROUTINENAMES AND NOT GENERATINGCFM }
  2051. {
  2052.     PBGetAltAccess and PBSetAltAccess are obsolete and will not be supported 
  2053.     on PowerPC. Equivalent functionality is provided by the routines 
  2054.     PBGetForeignPrivs and PBSetForeignPrivs.
  2055. }
  2056. FUNCTION PBGetAltAccessSync(paramBlock: HParmBlkPtr): OSErr;
  2057.     {$IFC NOT GENERATINGCFM}
  2058.     INLINE $205F, $7060, $A060, $3E80;
  2059.     {$ENDC}
  2060. FUNCTION PBGetAltAccessAsync(paramBlock: HParmBlkPtr): OSErr;
  2061.     {$IFC NOT GENERATINGCFM}
  2062.     INLINE $205F, $7060, $A460, $3E80;
  2063.     {$ENDC}
  2064. FUNCTION PBSetAltAccessSync(paramBlock: HParmBlkPtr): OSErr;
  2065.     {$IFC NOT GENERATINGCFM}
  2066.     INLINE $205F, $7061, $A060, $3E80;
  2067.     {$ENDC}
  2068. FUNCTION PBSetAltAccessAsync(paramBlock: HParmBlkPtr): OSErr;
  2069.     {$IFC NOT GENERATINGCFM}
  2070.     INLINE $205F, $7061, $A460, $3E80;
  2071.     {$ENDC}
  2072. FUNCTION PBGetAltAccess(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2073. FUNCTION PBSetAltAccess(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2074. {$ENDC}
  2075. {$IFC OLDROUTINENAMES }
  2076. {
  2077.     The PBxxx() routines are obsolete.  
  2078.     
  2079.     Use the PBxxxSync() or PBxxxAsync() version instead.
  2080. }
  2081. FUNCTION PBGetVInfo(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2082. FUNCTION PBXGetVolInfo(paramBlock: XVolumeParamPtr; async: BOOLEAN): OSErr;
  2083. FUNCTION PBGetVol(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2084. FUNCTION PBSetVol(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2085. FUNCTION PBFlushVol(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2086. FUNCTION PBCreate(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2087. FUNCTION PBDelete(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2088. FUNCTION PBOpenDF(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2089. FUNCTION PBOpenRF(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2090. FUNCTION PBRename(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2091. FUNCTION PBGetFInfo(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2092. FUNCTION PBSetFInfo(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2093. FUNCTION PBSetFLock(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2094. FUNCTION PBRstFLock(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2095. FUNCTION PBSetFVers(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2096. FUNCTION PBAllocate(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2097. FUNCTION PBGetEOF(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2098. FUNCTION PBSetEOF(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2099. FUNCTION PBGetFPos(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2100. FUNCTION PBSetFPos(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2101. FUNCTION PBFlushFile(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2102. FUNCTION PBCatSearch(paramBlock: CSParamPtr; async: BOOLEAN): OSErr;
  2103. FUNCTION PBOpenWD(paramBlock: WDPBPtr; async: BOOLEAN): OSErr;
  2104. FUNCTION PBCloseWD(paramBlock: WDPBPtr; async: BOOLEAN): OSErr;
  2105. FUNCTION PBHSetVol(paramBlock: WDPBPtr; async: BOOLEAN): OSErr;
  2106. FUNCTION PBHGetVol(paramBlock: WDPBPtr; async: BOOLEAN): OSErr;
  2107. FUNCTION PBCatMove(paramBlock: CMovePBPtr; async: BOOLEAN): OSErr;
  2108. FUNCTION PBDirCreate(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2109. FUNCTION PBGetWDInfo(paramBlock: WDPBPtr; async: BOOLEAN): OSErr;
  2110. FUNCTION PBGetFCBInfo(paramBlock: FCBPBPtr; async: BOOLEAN): OSErr;
  2111. FUNCTION PBGetCatInfo(paramBlock: CInfoPBPtr; async: BOOLEAN): OSErr;
  2112. FUNCTION PBSetCatInfo(paramBlock: CInfoPBPtr; async: BOOLEAN): OSErr;
  2113. FUNCTION PBAllocContig(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2114. FUNCTION PBLockRange(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2115. FUNCTION PBUnlockRange(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2116. FUNCTION PBSetVInfo(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2117. FUNCTION PBHGetVInfo(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2118. FUNCTION PBHOpen(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2119. FUNCTION PBHOpenRF(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2120. FUNCTION PBHOpenDF(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2121. FUNCTION PBHCreate(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2122. FUNCTION PBHDelete(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2123. FUNCTION PBHRename(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2124. FUNCTION PBHRstFLock(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2125. FUNCTION PBHSetFLock(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2126. FUNCTION PBHGetFInfo(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2127. FUNCTION PBHSetFInfo(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2128. FUNCTION PBMakeFSSpec(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2129. FUNCTION PBHGetVolParms(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2130. FUNCTION PBHGetLogInInfo(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2131. FUNCTION PBHGetDirAccess(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2132. FUNCTION PBHSetDirAccess(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2133. FUNCTION PBHMapID(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2134. FUNCTION PBHMapName(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2135. FUNCTION PBHCopyFile(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2136. FUNCTION PBHMoveRename(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2137. FUNCTION PBHOpenDeny(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2138. FUNCTION PBHOpenRFDeny(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2139. FUNCTION PBExchangeFiles(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2140. FUNCTION PBCreateFileIDRef(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2141. FUNCTION PBResolveFileIDRef(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2142. FUNCTION PBDeleteFileIDRef(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2143. FUNCTION PBGetForeignPrivs(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2144. FUNCTION PBSetForeignPrivs(paramBlock: HParmBlkPtr; async: BOOLEAN): OSErr;
  2145. FUNCTION PBDTAddIcon(paramBlock: DTPBPtr; async: BOOLEAN): OSErr;
  2146. FUNCTION PBDTGetIcon(paramBlock: DTPBPtr; async: BOOLEAN): OSErr;
  2147. FUNCTION PBDTGetIconInfo(paramBlock: DTPBPtr; async: BOOLEAN): OSErr;
  2148. FUNCTION PBDTAddAPPL(paramBlock: DTPBPtr; async: BOOLEAN): OSErr;
  2149. FUNCTION PBDTRemoveAPPL(paramBlock: DTPBPtr; async: BOOLEAN): OSErr;
  2150. FUNCTION PBDTGetAPPL(paramBlock: DTPBPtr; async: BOOLEAN): OSErr;
  2151. FUNCTION PBDTSetComment(paramBlock: DTPBPtr; async: BOOLEAN): OSErr;
  2152. FUNCTION PBDTRemoveComment(paramBlock: DTPBPtr; async: BOOLEAN): OSErr;
  2153. FUNCTION PBDTGetComment(paramBlock: DTPBPtr; async: BOOLEAN): OSErr;
  2154. FUNCTION PBDTFlush(paramBlock: DTPBPtr; async: BOOLEAN): OSErr;
  2155. FUNCTION PBDTReset(paramBlock: DTPBPtr; async: BOOLEAN): OSErr;
  2156. FUNCTION PBDTGetInfo(paramBlock: DTPBPtr; async: BOOLEAN): OSErr;
  2157. FUNCTION PBDTDelete(paramBlock: DTPBPtr; async: BOOLEAN): OSErr;
  2158. {$IFC OLDROUTINELOCATIONS }
  2159. FUNCTION PBOpen(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2160. FUNCTION PBClose(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2161. FUNCTION PBRead(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2162. FUNCTION PBWrite(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  2163. {$ENDC}
  2164. {$ENDC}
  2165. {$ENDC}
  2166. {$ALIGN RESET}
  2167. {$POP}
  2168.  
  2169. {$SETC UsingIncludes := FilesIncludes}
  2170.  
  2171. {$ENDC} {__FILES__}
  2172.  
  2173. {$IFC NOT UsingIncludes}
  2174.  END.
  2175. {$ENDC}
  2176.